PublicDashboards: Audit table pagination (#69823)

2023-06-21 10:48:09 -03:00
parent ed5a697825
commit ee73d41d24
20 changed files with 475 additions and 305 deletions
@@ -663,7 +663,7 @@ func TestGetQueryDataResponse(t *testing.T) {
 	sqlStore := sqlstore.InitTestDB(t)
 	dashboardStore, err := dashboardsDB.ProvideDashboardStore(sqlStore, sqlStore.Cfg, featuremgmt.WithFeatures(), tagimpl.ProvideService(sqlStore, sqlStore.Cfg), quotatest.New(false, nil))
 	require.NoError(t, err)
-	publicdashboardStore := database.ProvideStore(sqlStore)
+	publicdashboardStore := database.ProvideStore(sqlStore, sqlStore.Cfg, featuremgmt.WithFeatures())
 	serviceWrapper := ProvideServiceWrapper(publicdashboardStore)
 	fakeQueryService := &query.FakeQueryService{}
 	fakeQueryService.On("QueryData", mock.Anything, mock.Anything, mock.Anything, mock.Anything).Return(&backend.QueryDataResponse{}, nil)
@@ -1109,7 +1109,7 @@ func TestGetMetricRequest(t *testing.T) {
 	sqlStore := db.InitTestDB(t)
 	dashboardStore, err := dashboardsDB.ProvideDashboardStore(sqlStore, sqlStore.Cfg, featuremgmt.WithFeatures(), tagimpl.ProvideService(sqlStore, sqlStore.Cfg), quotatest.New(false, nil))
 	require.NoError(t, err)
-	publicdashboardStore := database.ProvideStore(sqlStore)
+	publicdashboardStore := database.ProvideStore(sqlStore, sqlStore.Cfg, featuremgmt.WithFeatures())
 	dashboard := insertTestDashboard(t, dashboardStore, "testDashie", 1, 0, true, []map[string]interface{}{}, nil)
 	publicDashboard := &PublicDashboard{
 		Uid:          "1",
@@ -1194,7 +1194,7 @@ func TestBuildMetricRequest(t *testing.T) {
 	sqlStore := db.InitTestDB(t)
 	dashboardStore, err := dashboardsDB.ProvideDashboardStore(sqlStore, sqlStore.Cfg, featuremgmt.WithFeatures(), tagimpl.ProvideService(sqlStore, sqlStore.Cfg), quotatest.New(false, nil))
 	require.NoError(t, err)
-	publicdashboardStore := database.ProvideStore(sqlStore)
+	publicdashboardStore := database.ProvideStore(sqlStore, sqlStore.Cfg, featuremgmt.WithFeatures())
 	serviceWrapper := ProvideServiceWrapper(publicdashboardStore)
 	publicDashboard := insertTestDashboard(t, dashboardStore, "testDashie", 1, 0, true, []map[string]interface{}{}, nil)
 	nonPublicDashboard := insertTestDashboard(t, dashboardStore, "testNonPublicDashie", 1, 0, true, []map[string]interface{}{}, nil)
@@ -276,14 +276,18 @@ func (pd *PublicDashboardServiceImpl) NewPublicDashboardAccessToken(ctx context.
 	return "", ErrInternalServerError.Errorf("failed to generate a unique accessToken for public dashboard")
 }

-// FindAll Returns a list of public dashboards by orgId
-func (pd *PublicDashboardServiceImpl) FindAll(ctx context.Context, u *user.SignedInUser, orgId int64) ([]PublicDashboardListResponse, error) {
-	publicDashboards, err := pd.store.FindAll(ctx, orgId)
+// FindAllWithPagination Returns a list of public dashboards by orgId, based on permissions and with pagination
+func (pd *PublicDashboardServiceImpl) FindAllWithPagination(ctx context.Context, query *PublicDashboardListQuery) (*PublicDashboardListResponseWithPagination, error) {
+	query.Offset = query.Limit * (query.Page - 1)
+	resp, err := pd.store.FindAllWithPagination(ctx, query)
 	if err != nil {
-		return nil, ErrInternalServerError.Errorf("FindAll: %w", err)
+		return nil, ErrInternalServerError.Errorf("FindAllWithPagination: %w", err)
 	}

-	return pd.filterDashboardsByPermissions(ctx, u, publicDashboards)
+	resp.Page = query.Page
+	resp.PerPage = query.Limit
+
+	return resp, nil
 }

 func (pd *PublicDashboardServiceImpl) ExistsEnabledByDashboardUid(ctx context.Context, dashboardUid string) (bool, error) {
@@ -371,25 +375,6 @@ func (pd *PublicDashboardServiceImpl) logIsEnabledChanged(existingPubdash *Publi
 	}
 }

-// Filter out dashboards that user does not have read access to
-func (pd *PublicDashboardServiceImpl) filterDashboardsByPermissions(ctx context.Context, u *user.SignedInUser, publicDashboards []PublicDashboardListResponse) ([]PublicDashboardListResponse, error) {
-	result := make([]PublicDashboardListResponse, 0)
-
-	for i := range publicDashboards {
-		hasAccess, err := pd.ac.Evaluate(ctx, u, accesscontrol.EvalPermission(dashboards.ActionDashboardsRead, dashboards.ScopeDashboardsProvider.GetResourceScopeUID(publicDashboards[i].DashboardUid)))
-		// If original dashboard does not exist, the public dashboard is an orphan. We want to list it anyway
-		if err != nil && !errors.Is(err, dashboards.ErrDashboardNotFound) {
-			return nil, ErrInternalServerError.Errorf("filterDashboardsByPermissions: error evaluating permissions %w", err)
-		}
-
-		// If user has access to the original dashboard or the dashboard does not exist, add the pubdash to the result
-		if hasAccess || errors.Is(err, dashboards.ErrDashboardNotFound) {
-			result = append(result, publicDashboards[i])
-		}
-	}
-	return result, nil
-}
-
 // Checks to see if PublicDashboard.ExistsEnabledByDashboardUid is true on create or changed on update
 func publicDashboardIsEnabledChanged(existingPubdash *PublicDashboard, newPubdash *PublicDashboard) bool {
 	// creating dashboard, enabled true
@@ -195,7 +195,7 @@ func TestCreatePublicDashboard(t *testing.T) {
 		quotaService := quotatest.New(false, nil)
 		dashboardStore, err := dashboardsDB.ProvideDashboardStore(sqlStore, sqlStore.Cfg, featuremgmt.WithFeatures(), tagimpl.ProvideService(sqlStore, sqlStore.Cfg), quotaService)
 		require.NoError(t, err)
-		publicdashboardStore := database.ProvideStore(sqlStore)
+		publicdashboardStore := database.ProvideStore(sqlStore, sqlStore.Cfg, featuremgmt.WithFeatures())
 		dashboard := insertTestDashboard(t, dashboardStore, "testDashie", 1, 0, true, []map[string]interface{}{}, nil)
 		serviceWrapper := ProvideServiceWrapper(publicdashboardStore)

@@ -285,7 +285,7 @@ func TestCreatePublicDashboard(t *testing.T) {
 			quotaService := quotatest.New(false, nil)
 			dashboardStore, err := dashboardsDB.ProvideDashboardStore(sqlStore, sqlStore.Cfg, featuremgmt.WithFeatures(), tagimpl.ProvideService(sqlStore, sqlStore.Cfg), quotaService)
 			require.NoError(t, err)
-			publicdashboardStore := database.ProvideStore(sqlStore)
+			publicdashboardStore := database.ProvideStore(sqlStore, sqlStore.Cfg, featuremgmt.WithFeatures())
 			dashboard := insertTestDashboard(t, dashboardStore, "testDashie", 1, 0, true, []map[string]interface{}{}, nil)
 			serviceWrapper := ProvideServiceWrapper(publicdashboardStore)

@@ -325,7 +325,7 @@ func TestCreatePublicDashboard(t *testing.T) {
 		quotaService := quotatest.New(false, nil)
 		dashboardStore, err := dashboardsDB.ProvideDashboardStore(sqlStore, sqlStore.Cfg, featuremgmt.WithFeatures(), tagimpl.ProvideService(sqlStore, sqlStore.Cfg), quotaService)
 		require.NoError(t, err)
-		publicdashboardStore := database.ProvideStore(sqlStore)
+		publicdashboardStore := database.ProvideStore(sqlStore, sqlStore.Cfg, featuremgmt.WithFeatures())
 		dashboard := insertTestDashboard(t, dashboardStore, "testDashie", 1, 0, true, []map[string]interface{}{}, nil)
 		serviceWrapper := ProvideServiceWrapper(publicdashboardStore)

@@ -359,7 +359,7 @@ func TestCreatePublicDashboard(t *testing.T) {
 		quotaService := quotatest.New(false, nil)
 		dashboardStore, err := dashboardsDB.ProvideDashboardStore(sqlStore, sqlStore.Cfg, featuremgmt.WithFeatures(), tagimpl.ProvideService(sqlStore, sqlStore.Cfg), quotaService)
 		require.NoError(t, err)
-		publicdashboardStore := database.ProvideStore(sqlStore)
+		publicdashboardStore := database.ProvideStore(sqlStore, sqlStore.Cfg, featuremgmt.WithFeatures())
 		templateVars := make([]map[string]interface{}, 1)
 		dashboard := insertTestDashboard(t, dashboardStore, "testDashie", 1, 0, true, templateVars, nil)
 		serviceWrapper := ProvideServiceWrapper(publicdashboardStore)
@@ -474,7 +474,7 @@ func TestCreatePublicDashboard(t *testing.T) {
 		quotaService := quotatest.New(false, nil)
 		dashboardStore, err := dashboardsDB.ProvideDashboardStore(sqlStore, sqlStore.Cfg, featuremgmt.WithFeatures(), tagimpl.ProvideService(sqlStore, sqlStore.Cfg), quotaService)
 		require.NoError(t, err)
-		publicdashboardStore := database.ProvideStore(sqlStore)
+		publicdashboardStore := database.ProvideStore(sqlStore, sqlStore.Cfg, featuremgmt.WithFeatures())
 		dashboard := insertTestDashboard(t, dashboardStore, "testDashie", 1, 0, true, []map[string]interface{}{}, nil)
 		serviceWrapper := ProvideServiceWrapper(publicdashboardStore)

@@ -519,7 +519,7 @@ func TestUpdatePublicDashboard(t *testing.T) {
 		quotaService := quotatest.New(false, nil)
 		dashboardStore, err := dashboardsDB.ProvideDashboardStore(sqlStore, sqlStore.Cfg, featuremgmt.WithFeatures(), tagimpl.ProvideService(sqlStore, sqlStore.Cfg), quotaService)
 		require.NoError(t, err)
-		publicdashboardStore := database.ProvideStore(sqlStore)
+		publicdashboardStore := database.ProvideStore(sqlStore, sqlStore.Cfg, featuremgmt.WithFeatures())
 		serviceWrapper := ProvideServiceWrapper(publicdashboardStore)
 		dashboard := insertTestDashboard(t, dashboardStore, "testDashie", 1, 0, true, []map[string]interface{}{}, nil)

@@ -588,7 +588,7 @@ func TestUpdatePublicDashboard(t *testing.T) {
 		quotaService := quotatest.New(false, nil)
 		dashboardStore, err := dashboardsDB.ProvideDashboardStore(sqlStore, sqlStore.Cfg, featuremgmt.WithFeatures(), tagimpl.ProvideService(sqlStore, sqlStore.Cfg), quotaService)
 		require.NoError(t, err)
-		publicdashboardStore := database.ProvideStore(sqlStore)
+		publicdashboardStore := database.ProvideStore(sqlStore, sqlStore.Cfg, featuremgmt.WithFeatures())
 		serviceWrapper := ProvideServiceWrapper(publicdashboardStore)

 		dashboard := insertTestDashboard(t, dashboardStore, "testDashie", 1, 0, true, []map[string]interface{}{}, nil)
@@ -686,7 +686,7 @@ func TestUpdatePublicDashboard(t *testing.T) {
 			quotaService := quotatest.New(false, nil)
 			dashboardStore, err := dashboardsDB.ProvideDashboardStore(sqlStore, sqlStore.Cfg, featuremgmt.WithFeatures(), tagimpl.ProvideService(sqlStore, sqlStore.Cfg), quotaService)
 			require.NoError(t, err)
-			publicdashboardStore := database.ProvideStore(sqlStore)
+			publicdashboardStore := database.ProvideStore(sqlStore, sqlStore.Cfg, featuremgmt.WithFeatures())
 			serviceWrapper := ProvideServiceWrapper(publicdashboardStore)
 			dashboard := insertTestDashboard(t, dashboardStore, "testDashie", 1, 0, true, []map[string]interface{}{}, nil)

@@ -915,152 +915,15 @@ func TestDashboardEnabledChanged(t *testing.T) {
 func TestPublicDashboardServiceImpl_ListPublicDashboards(t *testing.T) {
 	type args struct {
 		ctx   context.Context
-		u     *user.SignedInUser
-		orgId int64
+		query *PublicDashboardListQuery
 	}

-	testCases := []struct {
-		name         string
-		args         args
-		evaluateFunc func(c context.Context, u *user.SignedInUser, e accesscontrol.Evaluator) (bool, error)
-		want         []PublicDashboardListResponse
-		wantErr      assert.ErrorAssertionFunc
-	}{
-		{
-			name: "should return empty list when user does not have permissions to read any dashboard",
-			args: args{
-				ctx:   context.Background(),
-				u:     &user.SignedInUser{OrgID: 1},
-				orgId: 1,
-			},
-			want:    []PublicDashboardListResponse{},
-			wantErr: assert.NoError,
-		},
-		{
-			name: "should return all dashboards when has permissions",
-			args: args{
-				ctx: context.Background(),
-				u: &user.SignedInUser{OrgID: 1, Permissions: map[int64]map[string][]string{
-					1: {"dashboards:read": {
-						"dashboards:uid:0S6TmO67z", "dashboards:uid:1S6TmO67z", "dashboards:uid:2S6TmO67z", "dashboards:uid:9S6TmO67z",
-					}}},
-				},
-				orgId: 1,
-			},
-			want: []PublicDashboardListResponse{
-				{
-					Uid:          "0GwW7mgVk",
-					AccessToken:  "0b458cb7fe7f42c68712078bcacee6e3",
-					DashboardUid: "0S6TmO67z",
-					Title:        "my zero dashboard",
-					IsEnabled:    true,
-				},
-				{
-					Uid:          "1GwW7mgVk",
-					AccessToken:  "1b458cb7fe7f42c68712078bcacee6e3",
-					DashboardUid: "1S6TmO67z",
-					Title:        "my first dashboard",
-					IsEnabled:    true,
-				},
-				{
-					Uid:          "2GwW7mgVk",
-					AccessToken:  "2b458cb7fe7f42c68712078bcacee6e3",
-					DashboardUid: "2S6TmO67z",
-					Title:        "my second dashboard",
-					IsEnabled:    false,
-				},
-				{
-					Uid:          "9GwW7mgVk",
-					AccessToken:  "deletedashboardaccesstoken",
-					DashboardUid: "9S6TmO67z",
-					Title:        "",
-					IsEnabled:    true,
-				},
-			},
-			wantErr: assert.NoError,
-		},
-		{
-			name: "should return only dashboards with permissions",
-			args: args{
-				ctx: context.Background(),
-				u: &user.SignedInUser{OrgID: 1, Permissions: map[int64]map[string][]string{
-					1: {"dashboards:read": {"dashboards:uid:0S6TmO67z"}}},
-				},
-				orgId: 1,
-			},
-			want: []PublicDashboardListResponse{
-				{
-					Uid:          "0GwW7mgVk",
-					AccessToken:  "0b458cb7fe7f42c68712078bcacee6e3",
-					DashboardUid: "0S6TmO67z",
-					Title:        "my zero dashboard",
-					IsEnabled:    true,
-				},
-			},
-			wantErr: assert.NoError,
-		},
-		{
-			name: "should return orphaned public dashboards",
-			args: args{
-				ctx: context.Background(),
-				u: &user.SignedInUser{OrgID: 1, Permissions: map[int64]map[string][]string{
-					1: {"dashboards:read": {"dashboards:uid:0S6TmO67z"}}},
-				},
-				orgId: 1,
-			},
-			evaluateFunc: func(c context.Context, u *user.SignedInUser, e accesscontrol.Evaluator) (bool, error) {
-				return false, dashboards.ErrDashboardNotFound
-			},
-			want: []PublicDashboardListResponse{
-				{
-					Uid:          "0GwW7mgVk",
-					AccessToken:  "0b458cb7fe7f42c68712078bcacee6e3",
-					DashboardUid: "0S6TmO67z",
-					Title:        "my zero dashboard",
-					IsEnabled:    true,
-				},
-				{
-					Uid:          "1GwW7mgVk",
-					AccessToken:  "1b458cb7fe7f42c68712078bcacee6e3",
-					DashboardUid: "1S6TmO67z",
-					Title:        "my first dashboard",
-					IsEnabled:    true,
-				},
-				{
-					Uid:          "2GwW7mgVk",
-					AccessToken:  "2b458cb7fe7f42c68712078bcacee6e3",
-					DashboardUid: "2S6TmO67z",
-					Title:        "my second dashboard",
-					IsEnabled:    false,
-				},
-				{
-					Uid:          "9GwW7mgVk",
-					AccessToken:  "deletedashboardaccesstoken",
-					DashboardUid: "9S6TmO67z",
-					Title:        "",
-					IsEnabled:    true,
-				},
-			},
-			wantErr: assert.NoError,
-		},
-		{
-			name: "errors different than not data found should be returned",
-			args: args{
-				ctx: context.Background(),
-				u: &user.SignedInUser{OrgID: 1, Permissions: map[int64]map[string][]string{
-					1: {"dashboards:read": {"dashboards:uid:0S6TmO67z"}}},
-				},
-				orgId: 1,
-			},
-			evaluateFunc: func(c context.Context, u *user.SignedInUser, e accesscontrol.Evaluator) (bool, error) {
-				return false, dashboards.ErrDashboardCorrupt
-			},
-			want:    nil,
-			wantErr: assert.Error,
-		},
+	type mockResponse struct {
+		PublicDashboardListResponseWithPagination *PublicDashboardListResponseWithPagination
+		Err                                       error
 	}

-	mockedDashboards := []PublicDashboardListResponse{
+	mockedDashboards := []*PublicDashboardListResponse{
 		{
 			Uid:          "0GwW7mgVk",
 			AccessToken:  "0b458cb7fe7f42c68712078bcacee6e3",
@@ -1091,9 +954,62 @@ func TestPublicDashboardServiceImpl_ListPublicDashboards(t *testing.T) {
 		},
 	}

-	store := NewFakePublicDashboardStore(t)
-	store.On("FindAll", mock.Anything, mock.Anything).
-		Return(mockedDashboards, nil)
+	testCases := []struct {
+		name         string
+		args         args
+		want         *PublicDashboardListResponseWithPagination
+		mockResponse *mockResponse
+		wantErr      assert.ErrorAssertionFunc
+	}{
+		{
+			name: "should return correct pagination response",
+			args: args{
+				ctx: context.Background(),
+				query: &PublicDashboardListQuery{
+					User: &user.SignedInUser{OrgID: 1, Permissions: map[int64]map[string][]string{
+						1: {"dashboards:read": {"dashboards:uid:0S6TmO67z"}}},
+					},
+					OrgID: 1,
+					Page:  1,
+					Limit: 50,
+				},
+			},
+			mockResponse: &mockResponse{
+				PublicDashboardListResponseWithPagination: &PublicDashboardListResponseWithPagination{
+					TotalCount:       int64(len(mockedDashboards)),
+					PublicDashboards: mockedDashboards,
+				},
+				Err: nil,
+			},
+			want: &PublicDashboardListResponseWithPagination{
+				Page:             1,
+				PerPage:          50,
+				TotalCount:       int64(len(mockedDashboards)),
+				PublicDashboards: mockedDashboards,
+			},
+			wantErr: assert.NoError,
+		},
+		{
+			name: "should return error when store returns error",
+			args: args{
+				ctx: context.Background(),
+				query: &PublicDashboardListQuery{
+					User: &user.SignedInUser{OrgID: 1, Permissions: map[int64]map[string][]string{
+						1: {"dashboards:read": {"dashboards:uid:0S6TmO67z"}}},
+					},
+					OrgID: 1,
+					Page:  1,
+					Limit: 50,
+				},
+			},
+			mockResponse: &mockResponse{
+				PublicDashboardListResponseWithPagination: nil,
+				Err: errors.New("an err"),
+			},
+			want:    nil,
+			wantErr: assert.Error,
+		},
+	}

 	ac := tests.SetupMockAccesscontrol(t,
 		func(c context.Context, siu *user.SignedInUser, _ accesscontrol.Options) ([]accesscontrol.Permission, error) {
@@ -1102,21 +1018,23 @@ func TestPublicDashboardServiceImpl_ListPublicDashboards(t *testing.T) {
 		false,
 	)

-	pd := &PublicDashboardServiceImpl{
-		log:   log.New("test.logger"),
-		store: store,
-		ac:    ac,
-	}
-
 	for _, tt := range testCases {
 		t.Run(tt.name, func(t *testing.T) {
-			ac.EvaluateFunc = tt.evaluateFunc
+			store := NewFakePublicDashboardStore(t)
+			store.On("FindAllWithPagination", mock.Anything, mock.Anything).
+				Return(tt.mockResponse.PublicDashboardListResponseWithPagination, tt.mockResponse.Err)

-			got, err := pd.FindAll(tt.args.ctx, tt.args.u, tt.args.orgId)
-			if !tt.wantErr(t, err, fmt.Sprintf("FindAll(%v, %v, %v)", tt.args.ctx, tt.args.u, tt.args.orgId)) {
+			pd := &PublicDashboardServiceImpl{
+				log:   log.New("test.logger"),
+				store: store,
+				ac:    ac,
+			}
+
+			got, err := pd.FindAllWithPagination(tt.args.ctx, tt.args.query)
+			if !tt.wantErr(t, err, fmt.Sprintf("FindAllWithPagination(%v, %v)", tt.args.ctx, tt.args.query)) {
 				return
 			}
-			assert.Equalf(t, tt.want, got, "FindAll(%v, %v, %v)", tt.args.ctx, tt.args.u, tt.args.orgId)
+			assert.Equalf(t, tt.want, got, "FindAllWithPagination(%v, %v)", tt.args.ctx, tt.args.query)
 		})
 	}
 }