Merge remote-tracking branch 'origin/main' into grafana-git-ui-sync

pkg/services/folder/folderimpl/folder.go

@@ -37,6 +37,7 @@ import (
 	"github.com/grafana/grafana/pkg/services/guardian"
 	"github.com/grafana/grafana/pkg/services/publicdashboards"
 	"github.com/grafana/grafana/pkg/services/search/model"
+	"github.com/grafana/grafana/pkg/services/search/sort"
 	"github.com/grafana/grafana/pkg/services/sqlstore"
 	"github.com/grafana/grafana/pkg/services/sqlstore/migrator"
 	"github.com/grafana/grafana/pkg/services/sqlstore/searchstore"
@@ -89,6 +90,7 @@ func ProvideService(
 	tracer tracing.Tracer,
 	resourceClient resource.ResourceClient,
 	dual dualwrite.Service,
+	sorter sort.Service,
 ) *Service {
 	srv := &Service{
 		log:                    slog.Default().With("logger", "folder-service"),
@@ -111,7 +113,7 @@ func ProvideService(
 	ac.RegisterScopeAttributeResolver(dashboards.NewFolderIDScopeResolver(folderStore, srv))
 	ac.RegisterScopeAttributeResolver(dashboards.NewFolderUIDScopeResolver(srv))
 
-	if features.IsEnabledGlobally(featuremgmt.FlagKubernetesFoldersServiceV2) {
+	if features.IsEnabledGlobally(featuremgmt.FlagKubernetesClientDashboardsFolders) {
 		k8sHandler := client.NewK8sHandler(
 			dual,
 			request.GetNamespaceMapper(cfg),
@@ -120,6 +122,7 @@ func ProvideService(
 			dashboardStore,
 			userService,
 			resourceClient,
+			sorter,
 		)
 
 		unifiedStore := ProvideUnifiedStore(k8sHandler, userService)
@@ -128,7 +131,7 @@ func ProvideService(
 		srv.k8sclient = k8sHandler
 	}
 
-	if features.IsEnabledGlobally(featuremgmt.FlagKubernetesCliDashboards) {
+	if features.IsEnabledGlobally(featuremgmt.FlagKubernetesClientDashboardsFolders) {
 		dashHandler := client.NewK8sHandler(
 			dual,
 			request.GetNamespaceMapper(cfg),
@@ -137,6 +140,7 @@ func ProvideService(
 			dashboardStore,
 			userService,
 			resourceClient,
+			sorter,
 		)
 		srv.dashboardK8sClient = dashHandler
 	}
@@ -191,7 +195,7 @@ func (s *Service) DBMigration(db db.DB) {
 }
 
 func (s *Service) SearchFolders(ctx context.Context, q folder.SearchFoldersQuery) (model.HitList, error) {
-	if s.features.IsEnabledGlobally(featuremgmt.FlagKubernetesFoldersServiceV2) {
+	if s.features.IsEnabledGlobally(featuremgmt.FlagKubernetesClientDashboardsFolders) {
 		// TODO:
 		// - implement filtering by alerting folders and k6 folders (see the dashboards store `FindDashboards` method for reference)
 		// - implement fallback on search client in unistore to go to legacy store (will need to read from dashboard store)
@@ -202,7 +206,7 @@ func (s *Service) SearchFolders(ctx context.Context, q folder.SearchFoldersQuery
 }
 
 func (s *Service) GetFolders(ctx context.Context, q folder.GetFoldersQuery) ([]*folder.Folder, error) {
-	if s.features.IsEnabledGlobally(featuremgmt.FlagKubernetesFoldersServiceV2) {
+	if s.features.IsEnabledGlobally(featuremgmt.FlagKubernetesClientDashboardsFolders) {
 		return s.getFoldersFromApiServer(ctx, q)
 	}
 	return s.GetFoldersLegacy(ctx, q)
@@ -261,7 +265,7 @@ func (s *Service) GetFoldersLegacy(ctx context.Context, q folder.GetFoldersQuery
 }
 
 func (s *Service) Get(ctx context.Context, q *folder.GetFolderQuery) (*folder.Folder, error) {
-	if s.features.IsEnabledGlobally(featuremgmt.FlagKubernetesFoldersServiceV2) {
+	if s.features.IsEnabledGlobally(featuremgmt.FlagKubernetesClientDashboardsFolders) {
 		return s.getFromApiServer(ctx, q)
 	}
 	return s.GetLegacy(ctx, q)
@@ -402,7 +406,7 @@ func (s *Service) setFullpath(ctx context.Context, f *folder.Folder, user identi
 }
 
 func (s *Service) GetChildren(ctx context.Context, q *folder.GetChildrenQuery) ([]*folder.Folder, error) {
-	if s.features.IsEnabledGlobally(featuremgmt.FlagKubernetesFoldersServiceV2) {
+	if s.features.IsEnabledGlobally(featuremgmt.FlagKubernetesClientDashboardsFolders) {
 		return s.getChildrenFromApiServer(ctx, q)
 	}
 	return s.GetChildrenLegacy(ctx, q)
@@ -672,7 +676,7 @@ func (s *Service) deduplicateAvailableFolders(ctx context.Context, folders []*fo
 }
 
 func (s *Service) GetParents(ctx context.Context, q folder.GetParentsQuery) ([]*folder.Folder, error) {
-	if s.features.IsEnabledGlobally(featuremgmt.FlagKubernetesFoldersServiceV2) {
+	if s.features.IsEnabledGlobally(featuremgmt.FlagKubernetesClientDashboardsFolders) {
 		return s.getParentsFromApiServer(ctx, q)
 	}
 	return s.GetParentsLegacy(ctx, q)
@@ -705,7 +709,7 @@ func (s *Service) getFolderByTitle(ctx context.Context, orgID int64, title strin
 }
 
 func (s *Service) Create(ctx context.Context, cmd *folder.CreateFolderCommand) (*folder.Folder, error) {
-	if s.features.IsEnabledGlobally(featuremgmt.FlagKubernetesFoldersServiceV2) {
+	if s.features.IsEnabledGlobally(featuremgmt.FlagKubernetesClientDashboardsFolders) {
 		return s.createOnApiServer(ctx, cmd)
 	}
 	return s.CreateLegacy(ctx, cmd)
@@ -824,7 +828,7 @@ func (s *Service) CreateLegacy(ctx context.Context, cmd *folder.CreateFolderComm
 }
 
 func (s *Service) Update(ctx context.Context, cmd *folder.UpdateFolderCommand) (*folder.Folder, error) {
-	if s.features.IsEnabledGlobally(featuremgmt.FlagKubernetesFoldersServiceV2) {
+	if s.features.IsEnabledGlobally(featuremgmt.FlagKubernetesClientDashboardsFolders) {
 		return s.updateOnApiServer(ctx, cmd)
 	}
 	return s.UpdateLegacy(ctx, cmd)
@@ -963,7 +967,7 @@ func prepareForUpdate(dashFolder *dashboards.Dashboard, orgId int64, userId int6
 }
 
 func (s *Service) Delete(ctx context.Context, cmd *folder.DeleteFolderCommand) error {
-	if s.features.IsEnabledGlobally(featuremgmt.FlagKubernetesFoldersServiceV2) {
+	if s.features.IsEnabledGlobally(featuremgmt.FlagKubernetesClientDashboardsFolders) {
 		return s.deleteFromApiServer(ctx, cmd)
 	}
 	return s.DeleteLegacy(ctx, cmd)
@@ -1086,7 +1090,7 @@ func (s *Service) legacyDelete(ctx context.Context, cmd *folder.DeleteFolderComm
 }
 
 func (s *Service) Move(ctx context.Context, cmd *folder.MoveFolderCommand) (*folder.Folder, error) {
-	if s.features.IsEnabledGlobally(featuremgmt.FlagKubernetesFoldersServiceV2) {
+	if s.features.IsEnabledGlobally(featuremgmt.FlagKubernetesClientDashboardsFolders) {
 		return s.moveOnApiServer(ctx, cmd)
 	}
 	return s.MoveLegacy(ctx, cmd)
@@ -1313,7 +1317,7 @@ func (s *Service) nestedFolderDelete(ctx context.Context, cmd *folder.DeleteFold
 }
 
 func (s *Service) GetDescendantCounts(ctx context.Context, q *folder.GetDescendantCountsQuery) (folder.DescendantCounts, error) {
-	if s.features.IsEnabledGlobally(featuremgmt.FlagKubernetesFoldersServiceV2) {
+	if s.features.IsEnabledGlobally(featuremgmt.FlagKubernetesClientDashboardsFolders) {
 		return s.getDescendantCountsFromApiServer(ctx, q)
 	}
 

pkg/services/folder/folderimpl/folder_test.go

@@ -44,6 +44,7 @@ import (
 	"github.com/grafana/grafana/pkg/services/org"
 	"github.com/grafana/grafana/pkg/services/publicdashboards"
 	"github.com/grafana/grafana/pkg/services/quota/quotatest"
+	"github.com/grafana/grafana/pkg/services/search/sort"
 	"github.com/grafana/grafana/pkg/services/sqlstore"
 	"github.com/grafana/grafana/pkg/services/store/entity"
 	"github.com/grafana/grafana/pkg/services/supportbundles/supportbundlestest"
@@ -68,7 +69,7 @@ func TestIntegrationProvideFolderService(t *testing.T) {
 		store := ProvideStore(db)
 		ProvideService(
 			store, ac, bus.ProvideBus(tracing.InitializeTracerForTest()),
-			nil, nil, nil, db, featuremgmt.WithFeatures(), supportbundlestest.NewFakeBundleService(), nil, cfg, nil, tracing.InitializeTracerForTest(), nil, dualwrite.ProvideTestService())
+			nil, nil, nil, db, featuremgmt.WithFeatures(), supportbundlestest.NewFakeBundleService(), nil, cfg, nil, tracing.InitializeTracerForTest(), nil, dualwrite.ProvideTestService(), sort.ProvideService())
 
 		require.Len(t, ac.Calls.RegisterAttributeScopeResolver, 2)
 	})
@@ -496,8 +497,7 @@ func TestIntegrationNestedFolderService(t *testing.T) {
 			})
 			publicDashboardFakeService.On("DeleteByDashboardUIDs", mock.Anything, mock.Anything, mock.Anything).Return(nil)
 
-			dashSrv, err := dashboardservice.ProvideDashboardServiceImpl(cfg, dashStore, folderStore, featuresFlagOn, folderPermissions, ac, serviceWithFlagOn, nestedFolderStore, nil,
-				client.MockTestRestConfig{}, nil, quotaService, nil, publicDashboardFakeService, nil, dualwrite.ProvideTestService())
+			dashSrv, err := dashboardservice.ProvideDashboardServiceImpl(cfg, dashStore, folderStore, featuresFlagOn, folderPermissions, ac, serviceWithFlagOn, nestedFolderStore, nil, client.MockTestRestConfig{}, nil, quotaService, nil, publicDashboardFakeService, nil, dualwrite.ProvideTestService(), sort.ProvideService())
 			require.NoError(t, err)
 			dashSrv.RegisterDashboardPermissions(dashboardPermissions)
 
@@ -583,7 +583,7 @@ func TestIntegrationNestedFolderService(t *testing.T) {
 			publicDashboardFakeService.On("DeleteByDashboardUIDs", mock.Anything, mock.Anything, mock.Anything).Return(nil)
 
 			dashSrv, err := dashboardservice.ProvideDashboardServiceImpl(cfg, dashStore, folderStore, featuresFlagOff,
-				folderPermissions, ac, serviceWithFlagOff, nestedFolderStore, nil, client.MockTestRestConfig{}, nil, quotaService, nil, publicDashboardFakeService, nil, dualwrite.ProvideTestService())
+				folderPermissions, ac, serviceWithFlagOff, nestedFolderStore, nil, client.MockTestRestConfig{}, nil, quotaService, nil, publicDashboardFakeService, nil, dualwrite.ProvideTestService(), sort.ProvideService())
 			require.NoError(t, err)
 			dashSrv.RegisterDashboardPermissions(dashboardPermissions)
 			alertStore, err := ngstore.ProvideDBStore(cfg, featuresFlagOff, db, serviceWithFlagOff, dashSrv, ac, b)
@@ -726,8 +726,7 @@ func TestIntegrationNestedFolderService(t *testing.T) {
 				tc.service.store = nestedFolderStore
 				publicDashboardFakeService.On("DeleteByDashboardUIDs", mock.Anything, mock.Anything, mock.Anything).Return(nil)
 
-				dashSrv, err := dashboardservice.ProvideDashboardServiceImpl(cfg, dashStore, folderStore, tc.featuresFlag, folderPermissions, ac, tc.service, tc.service.store, nil,
-					client.MockTestRestConfig{}, nil, quotaService, nil, publicDashboardFakeService, nil, dualwrite.ProvideTestService())
+				dashSrv, err := dashboardservice.ProvideDashboardServiceImpl(cfg, dashStore, folderStore, tc.featuresFlag, folderPermissions, ac, tc.service, tc.service.store, nil, client.MockTestRestConfig{}, nil, quotaService, nil, publicDashboardFakeService, nil, dualwrite.ProvideTestService(), sort.ProvideService())
 				require.NoError(t, err)
 				dashSrv.RegisterDashboardPermissions(dashboardPermissions)
 
@@ -1521,6 +1520,7 @@ func TestIntegrationNestedFolderSharedWithMe(t *testing.T) {
 		nil,
 		nil,
 		dualwrite.ProvideTestService(),
+		sort.ProvideService(),
 	)
 	require.NoError(t, err)
 	dashboardService.RegisterDashboardPermissions(dashboardPermissions)

pkg/services/folder/folderimpl/folder_unifiedstorage.go

@@ -26,7 +26,6 @@ import (
 	"github.com/grafana/grafana/pkg/services/folder"
 	"github.com/grafana/grafana/pkg/services/guardian"
 	"github.com/grafana/grafana/pkg/services/search/model"
-	"github.com/grafana/grafana/pkg/services/sqlstore/searchstore"
 	"github.com/grafana/grafana/pkg/services/store/entity"
 	"github.com/grafana/grafana/pkg/storage/unified/resource"
 	"github.com/grafana/grafana/pkg/storage/unified/search"
@@ -659,71 +658,43 @@ func (s *Service) deleteFromApiServer(ctx context.Context, cmd *folder.DeleteFol
 			return folder.ErrFolderNotEmpty.Errorf("folder contains %d alert rules", alertRulesInFolder)
 		}
 
-		// if dashboard restore is on we don't delete public dashboards, the hard delete will take care of it later
-		if !s.features.IsEnabledGlobally(featuremgmt.FlagDashboardRestore) {
-			// We need a list of dashboard uids inside the folder to delete related dashboards & public dashboards
-			var dashboardUIDs []string
-			// we cannot use the dashboard service directly due to circular dependencies,
-			// so either use the search client if the feature is enabled or use the dashboard store
-			if s.features.IsEnabledGlobally(featuremgmt.FlagKubernetesCliDashboards) {
-				request := &resource.ResourceSearchRequest{
-					Options: &resource.ListOptions{
-						Labels: []*resource.Requirement{},
-						Fields: []*resource.Requirement{
-							{
-								Key:      resource.SEARCH_FIELD_FOLDER,
-								Operator: string(selection.In),
-								Values:   folders,
-							},
-						},
+		// We need a list of dashboard uids inside the folder to delete related dashboards & public dashboards -
+		// we cannot use the dashboard service directly due to circular dependencies, so use the search client to get the dashboards
+		request := &resource.ResourceSearchRequest{
+			Options: &resource.ListOptions{
+				Labels: []*resource.Requirement{},
+				Fields: []*resource.Requirement{
+					{
+						Key:      resource.SEARCH_FIELD_FOLDER,
+						Operator: string(selection.In),
+						Values:   folders,
 					},
-					Limit: 100000}
+				},
+			},
+			Limit: 100000}
 
-				res, err := s.dashboardK8sClient.Search(ctx, cmd.OrgID, request)
-				if err != nil {
-					return folder.ErrInternal.Errorf("failed to fetch dashboards: %w", err)
-				}
+		res, err := s.dashboardK8sClient.Search(ctx, cmd.OrgID, request)
+		if err != nil {
+			return folder.ErrInternal.Errorf("failed to fetch dashboards: %w", err)
+		}
 
-				hits, err := dashboardsearch.ParseResults(res, 0)
-				if err != nil {
-					return folder.ErrInternal.Errorf("failed to fetch dashboards: %w", err)
-				}
-				dashboardUIDs = make([]string, len(hits.Hits))
-				for i, dashboard := range hits.Hits {
-					dashboardUIDs[i] = dashboard.Name
-					err = s.dashboardK8sClient.Delete(ctx, dashboard.Name, cmd.OrgID, metav1.DeleteOptions{})
-					if err != nil {
-						return folder.ErrInternal.Errorf("failed to delete child dashboard: %w", err)
-					}
-				}
-			} else {
-				dashes, err := s.dashboardStore.FindDashboards(ctx, &dashboards.FindPersistedDashboardsQuery{
-					SignedInUser: cmd.SignedInUser,
-					FolderUIDs:   folders,
-					OrgId:        cmd.OrgID,
-					Type:         searchstore.TypeDashboard,
-				})
-				if err != nil {
-					return folder.ErrInternal.Errorf("failed to fetch dashboards: %w", err)
-				}
-				dashboardUIDs = make([]string, len(dashes))
-				for i, dashboard := range dashes {
-					dashboardUIDs[i] = dashboard.UID
-					err = s.dashboardStore.DeleteDashboard(ctx, &dashboards.DeleteDashboardCommand{
-						UID:   dashboard.UID,
-						OrgID: cmd.OrgID,
-					})
-					if err != nil {
-						return folder.ErrInternal.Errorf("failed to delete child dashboard: %w", err)
-					}
-				}
-			}
-			// Delete all public dashboards in the folders
-			err = s.publicDashboardService.DeleteByDashboardUIDs(ctx, cmd.OrgID, dashboardUIDs)
+		hits, err := dashboardsearch.ParseResults(res, 0)
+		if err != nil {
+			return folder.ErrInternal.Errorf("failed to fetch dashboards: %w", err)
+		}
+		dashboardUIDs := make([]string, len(hits.Hits))
+		for i, dashboard := range hits.Hits {
+			dashboardUIDs[i] = dashboard.Name
+			err = s.dashboardK8sClient.Delete(ctx, dashboard.Name, cmd.OrgID, metav1.DeleteOptions{})
 			if err != nil {
-				return folder.ErrInternal.Errorf("failed to delete public dashboards: %w", err)
+				return folder.ErrInternal.Errorf("failed to delete child dashboard: %w", err)
 			}
 		}
+		// Delete all public dashboards in the folders
+		err = s.publicDashboardService.DeleteByDashboardUIDs(ctx, cmd.OrgID, dashboardUIDs)
+		if err != nil {
+			return folder.ErrInternal.Errorf("failed to delete public dashboards: %w", err)
+		}
 	}
 
 	err = s.unifiedStore.Delete(ctx, folders, cmd.OrgID)

pkg/services/folder/folderimpl/folder_unifiedstorage_test.go

@@ -36,6 +36,7 @@ import (
 	ngstore "github.com/grafana/grafana/pkg/services/ngalert/store"
 	"github.com/grafana/grafana/pkg/services/publicdashboards"
 	"github.com/grafana/grafana/pkg/services/search/model"
+	"github.com/grafana/grafana/pkg/services/search/sort"
 	"github.com/grafana/grafana/pkg/services/sqlstore"
 	"github.com/grafana/grafana/pkg/services/user"
 	"github.com/grafana/grafana/pkg/services/user/usertest"
@@ -179,11 +180,11 @@ func TestIntegrationFolderServiceViaUnifiedStorage(t *testing.T) {
 	}
 
 	featuresArr := []any{
-		featuremgmt.FlagKubernetesFoldersServiceV2}
+		featuremgmt.FlagKubernetesClientDashboardsFolders}
 	features := featuremgmt.WithFeatures(featuresArr...)
 
 	dashboardStore := dashboards.NewFakeDashboardStore(t)
-	k8sCli := client.NewK8sHandler(dualwrite.ProvideTestService(), request.GetNamespaceMapper(cfg), v0alpha1.FolderResourceInfo.GroupVersionResource(), restCfgProvider.GetRestConfig, dashboardStore, userService, nil)
+	k8sCli := client.NewK8sHandler(dualwrite.ProvideTestService(), request.GetNamespaceMapper(cfg), v0alpha1.FolderResourceInfo.GroupVersionResource(), restCfgProvider.GetRestConfig, dashboardStore, userService, nil, sort.ProvideService())
 	unifiedStore := ProvideUnifiedStore(k8sCli, userService)
 
 	ctx := context.Background()
@@ -206,6 +207,7 @@ func TestIntegrationFolderServiceViaUnifiedStorage(t *testing.T) {
 
 	publicDashboardService := publicdashboards.NewFakePublicDashboardServiceWrapper(t)
 
+	fakeK8sClient := new(client.MockK8sHandler)
 	folderService := &Service{
 		log:                    slog.New(logtest.NewTestHandler(t)).With("logger", "test-folder-service"),
 		unifiedStore:           unifiedStore,
@@ -216,7 +218,7 @@ func TestIntegrationFolderServiceViaUnifiedStorage(t *testing.T) {
 		metrics:                newFoldersMetrics(nil),
 		tracer:                 tracing.InitializeTracerForTest(),
 		k8sclient:              k8sCli,
-		dashboardStore:         dashboardStore,
+		dashboardK8sClient:     fakeK8sClient,
 		publicDashboardService: publicDashboardService,
 	}
 
@@ -348,7 +350,7 @@ func TestIntegrationFolderServiceViaUnifiedStorage(t *testing.T) {
 			})
 
 			t.Run("When deleting folder by uid should not return access denied error - ForceDeleteRules false", func(t *testing.T) {
-				dashboardStore.On("FindDashboards", mock.Anything, mock.Anything).Return([]dashboards.DashboardSearchProjection{}, nil).Once()
+				fakeK8sClient.On("Search", mock.Anything, mock.Anything, mock.Anything).Return(&resource.ResourceSearchResponse{Results: &resource.ResourceTable{}}, nil).Once()
 				publicDashboardService.On("DeleteByDashboardUIDs", mock.Anything, mock.Anything, mock.Anything).Return(nil)
 
 				err := folderService.Delete(ctx, &folder.DeleteFolderCommand{
@@ -362,6 +364,7 @@ func TestIntegrationFolderServiceViaUnifiedStorage(t *testing.T) {
 
 			t.Run("When deleting folder by uid, expectedForceDeleteRules as false, and dashboard Restore turned on should not return access denied error", func(t *testing.T) {
 				folderService.features = featuremgmt.WithFeatures(append(featuresArr, featuremgmt.FlagDashboardRestore)...)
+				fakeK8sClient.On("Search", mock.Anything, mock.Anything, mock.Anything).Return(&resource.ResourceSearchResponse{Results: &resource.ResourceTable{}}, nil).Once()
 
 				expectedForceDeleteRules := false
 				err := folderService.Delete(ctx, &folder.DeleteFolderCommand{
@@ -375,6 +378,7 @@ func TestIntegrationFolderServiceViaUnifiedStorage(t *testing.T) {
 
 			t.Run("When deleting folder by uid, expectedForceDeleteRules as true, and dashboard Restore turned on should not return access denied error", func(t *testing.T) {
 				folderService.features = featuremgmt.WithFeatures(append(featuresArr, featuremgmt.FlagDashboardRestore)...)
+				fakeK8sClient.On("Search", mock.Anything, mock.Anything, mock.Anything).Return(&resource.ResourceSearchResponse{Results: &resource.ResourceTable{}}, nil).Once()
 
 				expectedForceDeleteRules := true
 				err := folderService.Delete(ctx, &folder.DeleteFolderCommand{
@@ -526,7 +530,7 @@ func TestSearchFoldersFromApiServer(t *testing.T) {
 	}
 	service := Service{
 		k8sclient:    fakeK8sClient,
-		features:     featuremgmt.WithFeatures(featuremgmt.FlagKubernetesFoldersServiceV2),
+		features:     featuremgmt.WithFeatures(featuremgmt.FlagKubernetesClientDashboardsFolders),
 		unifiedStore: folderStore,
 	}
 	user := &user.SignedInUser{OrgID: 1}
@@ -779,7 +783,7 @@ func TestDeleteFoldersFromApiServer(t *testing.T) {
 		dashboardStore:         dashboardStore,
 		publicDashboardService: publicDashboardFakeService,
 		registry:               make(map[string]folder.RegistryService),
-		features:               featuremgmt.WithFeatures(featuremgmt.FlagKubernetesFoldersServiceV2),
+		features:               featuremgmt.WithFeatures(featuremgmt.FlagKubernetesClientDashboardsFolders),
 	}
 	user := &user.SignedInUser{OrgID: 1}
 	ctx := identity.WithRequester(context.Background(), user)
@@ -798,52 +802,22 @@ func TestDeleteFoldersFromApiServer(t *testing.T) {
 	require.NoError(t, service.RegisterService(alertingStore))
 
 	t.Run("Should delete folder", func(t *testing.T) {
-		dashboardStore.On("FindDashboards", mock.Anything, mock.Anything).Return([]dashboards.DashboardSearchProjection{}, nil).Once()
-		publicDashboardFakeService.On("DeleteByDashboardUIDs", mock.Anything, mock.Anything, mock.Anything).Return(nil).Once()
+		publicDashboardFakeService.On("DeleteByDashboardUIDs", mock.Anything, int64(1), []string{}).Return(nil).Once()
+		dashboardK8sclient.On("Search", mock.Anything, int64(1), mock.Anything).Return(&resource.ResourceSearchResponse{Results: &resource.ResourceTable{}}, nil).Once()
 		err := service.deleteFromApiServer(ctx, &folder.DeleteFolderCommand{
-			UID:          "uid",
+			UID:          "uid1",
 			OrgID:        1,
 			SignedInUser: user,
 		})
 		require.NoError(t, err)
-	})
-
-	t.Run("Should delete dashboards and public dashboards within the folder", func(t *testing.T) {
-		dashboardStore.On("FindDashboards", mock.Anything, mock.Anything).Return([]dashboards.DashboardSearchProjection{
-			{
-				UID:   "test",
-				OrgID: 1,
-			},
-			{
-				UID:   "test2",
-				OrgID: 1,
-			},
-		}, nil).Once()
-		dashboardStore.On("DeleteDashboard", mock.Anything, &dashboards.DeleteDashboardCommand{
-			UID:   "test",
-			OrgID: 1,
-		}).Return(nil).Once()
-		dashboardStore.On("DeleteDashboard", mock.Anything, &dashboards.DeleteDashboardCommand{
-			UID:   "test2",
-			OrgID: 1,
-		}).Return(nil).Once()
-		publicDashboardFakeService.On("DeleteByDashboardUIDs", mock.Anything, int64(1), []string{"test", "test2"}).Return(nil).Once()
-		err := service.deleteFromApiServer(ctx, &folder.DeleteFolderCommand{
-			UID:          "uid",
-			OrgID:        1,
-			SignedInUser: user,
-		})
-		require.NoError(t, err)
-		dashboardStore.AssertExpectations(t)
+		dashboardK8sclient.AssertExpectations(t)
 		publicDashboardFakeService.AssertExpectations(t)
 	})
 
-	// enable k8s ff for dashboards, retest
-	service.features = featuremgmt.WithFeatures(featuremgmt.FlagKubernetesFoldersServiceV2, featuremgmt.FlagKubernetesCliDashboards)
-
-	t.Run("Should delete dashboards and public dashboards within the folder through k8s if the ff is enabled", func(t *testing.T) {
-		publicDashboardFakeService.On("DeleteByDashboardUIDs", mock.Anything, int64(1), []string{"uid1"}).Return(nil).Once()
-		dashboardK8sclient.On("Delete", mock.Anything, "uid1", int64(1), mock.Anything).Return(nil).Once()
+	t.Run("Should delete folders, dashboards, and public dashboards within the folder", func(t *testing.T) {
+		fakeFolderStore.ExpectedFolders = []*folder.Folder{{UID: "uid2", ID: 2}}
+		dashboardK8sclient.On("Delete", mock.Anything, "test", int64(1), mock.Anything).Return(nil).Once()
+		dashboardK8sclient.On("Delete", mock.Anything, "test2", int64(1), mock.Anything).Return(nil).Once()
 		dashboardK8sclient.On("Search", mock.Anything, int64(1), &resource.ResourceSearchRequest{
 			Options: &resource.ListOptions{
 				Labels: []*resource.Requirement{},
@@ -851,7 +825,7 @@ func TestDeleteFoldersFromApiServer(t *testing.T) {
 					{
 						Key:      resource.SEARCH_FIELD_FOLDER,
 						Operator: string(selection.In),
-						Values:   []string{"uid1"},
+						Values:   []string{"uid", "uid2"},
 					},
 				},
 			},
@@ -870,11 +844,21 @@ func TestDeleteFoldersFromApiServer(t *testing.T) {
 				Rows: []*resource.ResourceTableRow{
 					{
 						Key: &resource.ResourceKey{
-							Name:     "uid1",
-							Resource: "folder",
+							Name:     "test",
+							Resource: "dashboard",
 						},
 						Cells: [][]byte{
-							[]byte("folder1"),
+							[]byte("uid"),
+							[]byte(""),
+						},
+					},
+					{
+						Key: &resource.ResourceKey{
+							Name:     "test2",
+							Resource: "dashboard",
+						},
+						Cells: [][]byte{
+							[]byte("uid2"),
 							[]byte(""),
 						},
 					},
@@ -882,13 +866,14 @@ func TestDeleteFoldersFromApiServer(t *testing.T) {
 			},
 			TotalHits: 1,
 		}, nil).Once()
+		publicDashboardFakeService.On("DeleteByDashboardUIDs", mock.Anything, int64(1), []string{"test", "test2"}).Return(nil).Once()
 		err := service.deleteFromApiServer(ctx, &folder.DeleteFolderCommand{
-			UID:          "uid1",
+			UID:          "uid",
 			OrgID:        1,
 			SignedInUser: user,
 		})
 		require.NoError(t, err)
+		dashboardStore.AssertExpectations(t)
 		publicDashboardFakeService.AssertExpectations(t)
-		dashboardK8sclient.AssertExpectations(t)
 	})
 }