Merge branch '479965-remove-search_issues_uses_work_items_index-ff' into 'master'

Remove search_issues_uses_work_items_index ff

See merge request https://gitlab.com/gitlab-org/gitlab/-/merge_requests/169378



Merged-by: Ravi Kumar <rkumar@gitlab.com>
Approved-by: Arturo Herrero <arturo.herrero@gmail.com>
Approved-by: Ravi Kumar <rkumar@gitlab.com>
Co-authored-by: Siddharth Dungarwal <sdungarwal@gitlab.com>

ee/config/feature_flags/development/search_issues_uses_work_items_index.yml

----
-name: search_issues_uses_work_items_index
-feature_issue_url: https://gitlab.com/gitlab-org/gitlab/-/issues/478007
-introduced_by_url: https://gitlab.com/gitlab-org/gitlab/-/merge_requests/163314
-rollout_issue_url: https://gitlab.com/gitlab-org/gitlab/-/issues/479965
-milestone: '17.4'
-type: development
-group: group::global search
-default_enabled: false

ee/lib/gitlab/elastic/search_results.rb

@@ -426,8 +426,7 @@ def work_item_index_available_for_searching_epics?
       end
       def work_item_index_available_for_searching_issues?
-        ::Feature.enabled?(:search_issues_uses_work_items_index, current_user) &&
-          ::Elastic::DataMigrationService.migration_has_finished?(:backfill_work_items)
+        ::Elastic::DataMigrationService.migration_has_finished?(:backfill_work_items)
       end
       def milestones(count_only: false)

ee/spec/features/search/elastic/group_search_spec.rb

@@ -8,7 +8,7 @@
   let_it_be(:user) { create(:user) }
   let_it_be(:group) { create(:group) }
-  let_it_be(:project) { create(:project, :repository, :wiki_repo, namespace: group) }
+  let_it_be(:project) { create(:project, :repository, :wiki_repo, group: group) }
   let_it_be(:group_wiki) { create(:group_wiki, group: group) }
   let_it_be(:wiki) { create(:project_wiki, project: project) }
@@ -66,6 +66,11 @@ def choose_group(group)
   end
   context 'when searching for issues and epics' do
+    let_it_be(:issue) { create(:work_item, project: project, title: 'chosen issue title') }
+    let_it_be(:epic) do
+      create(:work_item, :group_level, :epic_with_legacy_epic, namespace: group, title: 'chosen epic title')
+    end
+
     before_all do
       project.add_maintainer(user)
     end
@@ -81,34 +86,7 @@ def choose_group(group)
       choose_group(group)
     end
-    context 'when we do not use work_items index for search' do
-      let_it_be(:issue) { create(:issue, project: project, title: 'chosen issue title') }
-      let_it_be(:epic) { create(:epic, group: group, title: 'chosen epic title') }
-
-      before do
-        stub_feature_flags(search_issues_uses_work_items_index: false)
-        stub_feature_flags(search_epics_uses_work_items_index: false)
-      end
-
-      it 'finds issues and epics' do
-        # issues
-        submit_search('chosen')
-        select_search_scope('Issues')
-        expect(page).to have_content('chosen issue title')
-
-        # epics
-        submit_search('chosen')
-        select_search_scope('Epics')
-        expect(page).to have_content('chosen epic title')
-      end
-    end
-
     context 'when we use work_items index for search' do
-      let(:issue) { create(:work_item, project: project, title: 'chosen issue title') }
-      let(:epic) do
-        create(:work_item, :group_level, :epic_with_legacy_epic, namespace: group, title: 'chosen epic title')
-      end
-
       it 'finds issues and epics' do
         # issues
         submit_search('chosen')
@@ -125,15 +103,7 @@ def choose_group(group)
 end
 RSpec.describe 'Group elastic search redactions', feature_category: :global_search do
-  [:work_item, :issue].each do |document_type|
-    context "when we have document_type as #{document_type}" do
-      before do
-        stub_feature_flags(search_issues_uses_work_items_index: (document_type == :work_item))
-      end
-
-      it_behaves_like 'a redacted search results page', document_type: document_type do
-        let(:search_path) { group_path(public_group) }
-      end
-    end
+  it_behaves_like 'a redacted search results page' do
+    let(:search_path) { group_path(public_group) }
   end
 end

ee/spec/features/search/elastic/project_search_redactions_issue_spec.rb

-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe 'Project elastic search redactions issue', feature_category: :global_search do
-  context "when we have document_type as issue" do
-    before do
-      stub_feature_flags(search_issues_uses_work_items_index: false)
-    end
-
-    it_behaves_like 'a redacted search results page', document_type: :issue do
-      let(:search_path) { project_path(public_restricted_project) }
-    end
-  end
-end

ee/spec/features/search/elastic/project_search_redactions_work_item_spec.rb

@@ -3,13 +3,7 @@
 require 'spec_helper'
 RSpec.describe 'Project elastic search redactions work_item', feature_category: :global_search do
-  context "when we have document_type as work_item" do
-    before do
-      stub_feature_flags(search_issues_uses_work_items_index: true)
-    end
-
-    it_behaves_like 'a redacted search results page', document_type: :work_item do
-      let(:search_path) { project_path(public_restricted_project) }
-    end
+  it_behaves_like 'a redacted search results page' do
+    let(:search_path) { project_path(public_restricted_project) }
   end
 end

ee/spec/lib/gitlab/elastic/project_search_results_spec.rb

@@ -82,78 +82,65 @@
       context 'for issues' do
         let(:scope) { 'issues' }
-        [:work_item, :issue].each do |document_type|
-          context "when we have document_type as #{document_type}" do
-            let_it_be(:closed_result) { create(:issue, :closed, project: project, title: 'foo closed') }
-            let_it_be(:opened_result) { create(:issue, :opened, project: project, title: 'foo opened') }
-            let_it_be(:confidential_result) { create(:issue, :confidential, project: project, title: 'foo confidential') }
-
-            before do
-              ::Elastic::ProcessInitialBookkeepingService.track!(opened_result)
-              ::Elastic::ProcessInitialBookkeepingService.track!(closed_result)
-              ::Elastic::ProcessInitialBookkeepingService.track!(confidential_result)
-              stub_feature_flags(search_issues_uses_work_items_index: (document_type == :work_item))
-              ensure_elasticsearch_index!
-            end
-
-            context 'when advanced search query syntax is used' do
-              let(:query) { 'foo -banner' }
-
-              include_examples 'search results filtered by state'
-              include_examples 'search results filtered by confidential'
-              include_examples 'search results filtered by labels'
-            end
-
-            context 'when search_uses_match_queries flag is false' do
-              before do
-                stub_feature_flags(search_uses_match_queries: false)
-              end
-
-              include_examples 'search results filtered by state'
-              include_examples 'search results filtered by confidential'
-              include_examples 'search results filtered by labels'
-            end
-
-            include_examples 'search results filtered by state'
-            include_examples 'search results filtered by confidential'
-            include_examples 'search results filtered by labels'
-          end
-          context 'for merge_requests' do
-            let(:scope) { 'merge_requests' }
-            let_it_be(:opened_result) { create(:merge_request, :opened, source_project: project, title: 'foo opened') }
-            let_it_be(:closed_result) { create(:merge_request, :closed, source_project: project, title: 'foo closed') }
-            before do
-              ::Elastic::ProcessInitialBookkeepingService.track!(opened_result)
-              ::Elastic::ProcessInitialBookkeepingService.track!(closed_result)
-              ensure_elasticsearch_index!
-            end
-            include_examples 'search results filtered by state'
+        let_it_be(:closed_result) { create(:issue, :closed, project: project, title: 'foo closed') }
+        let_it_be(:opened_result) { create(:issue, :opened, project: project, title: 'foo opened') }
+        let_it_be(:confidential_result) { create(:issue, :confidential, project: project, title: 'foo confidential') }
+        before do
+          ::Elastic::ProcessInitialBookkeepingService.track!(opened_result)
+          ::Elastic::ProcessInitialBookkeepingService.track!(closed_result)
+          ::Elastic::ProcessInitialBookkeepingService.track!(confidential_result)
+          ensure_elasticsearch_index!
+        end
+        context 'when advanced search query syntax is used' do
+          let(:query) { 'foo -banner' }
+          include_examples 'search results filtered by state'
+          include_examples 'search results filtered by confidential'
+          include_examples 'search results filtered by labels'
+        end
+        context 'when search_uses_match_queries flag is false' do
+          before do
+            stub_feature_flags(search_uses_match_queries: false)
           end
-          context 'for blobs' do
-            it_behaves_like 'search results filtered by language'
-          end
+          include_examples 'search results filtered by state'
+          include_examples 'search results filtered by confidential'
+          include_examples 'search results filtered by labels'
         end
+
+        include_examples 'search results filtered by state'
+        include_examples 'search results filtered by confidential'
+        include_examples 'search results filtered by labels'
       end
-    end
-  end
-  describe 'confidential issues', :sidekiq_might_not_need_inline do
-    [:work_item, :issue].each do |document_type|
-      context "when we have document_type as #{document_type}" do
+      context 'for merge_requests' do
+        let(:scope) { 'merge_requests' }
+
+        let_it_be(:opened_result) { create(:merge_request, :opened, source_project: project, title: 'foo opened') }
+        let_it_be(:closed_result) { create(:merge_request, :closed, source_project: project, title: 'foo closed') }
+
         before do
-          stub_feature_flags(search_issues_uses_work_items_index: (document_type == :work_item))
+          ::Elastic::ProcessInitialBookkeepingService.track!(opened_result)
+          ::Elastic::ProcessInitialBookkeepingService.track!(closed_result)
+          ensure_elasticsearch_index!
         end
-        include_examples 'access restricted confidential issues' do
-          before do
-            ensure_elasticsearch_index!
-          end
-        end
+        include_examples 'search results filtered by state'
+      end
+
+      context 'for blobs' do
+        it_behaves_like 'search results filtered by language'
+      end
+    end
+  end
+
+  describe 'confidential issues', :sidekiq_might_not_need_inline do
+    include_examples 'access restricted confidential issues' do
+      before do
+        ensure_elasticsearch_index!
       end
     end
   end

ee/spec/lib/gitlab/elastic/search_results_spec.rb

@@ -123,18 +123,6 @@
         it_behaves_like 'loads expected aggregations'
       end
     end
-
-    context 'when search_issues_uses_work_items_index is false' do
-      let(:scope) { 'issues' }
-      let(:expected_aggregation_name) { 'labels' }
-      let(:feature_flag) { false }
-
-      before do
-        stub_feature_flags(search_issues_uses_work_items_index: false)
-      end
-
-      it_behaves_like 'loads expected aggregations'
-    end
   end
   shared_examples_for 'a paginated object' do |object_type|
@@ -441,241 +429,231 @@
     end
     describe 'ordering' do
-      [:work_item, :issue].each do |document_type|
-        context "when we have document_type as #{document_type}" do
-          let_it_be(:project) { create(:project, :public) }
-          let_it_be(:old_result) do
-            create(document_type, project: project, title: 'sorted old', created_at: 1.month.ago)
-          end
-          let_it_be(:new_result) do
-            create(document_type, project: project, title: 'sorted recent', created_at: 1.day.ago)
-          end
-          let_it_be(:very_old_result) do
-            create(document_type, project: project, title: 'sorted very old', created_at: 1.year.ago)
-          end
-          let_it_be(:old_updated) do
-            create(document_type, project: project, title: 'updated old', updated_at: 1.month.ago)
-          end
-          let_it_be(:new_updated) do
-            create(document_type, project: project, title: 'updated recent', updated_at: 1.day.ago)
-          end
-          let_it_be(:very_old_updated) do
-            create(document_type, project: project, title: 'updated very old', updated_at: 1.year.ago)
-          end
-          let_it_be(:less_popular_result) do
-            create(document_type, project: project, title: 'less popular', upvotes_count: 10)
-          end
-          let_it_be(:non_popular_result) do
-            create(document_type, project: project, title: 'non popular', upvotes_count: 1)
-          end
-          let_it_be(:popular_result) do
-            create(document_type, project: project, title: 'popular', upvotes_count: 100)
-          end
-          before do
-            ::Elastic::ProcessInitialBookkeepingService.backfill_projects!(project)
-            stub_feature_flags(search_issues_uses_work_items_index: (document_type == :work_item))
-            ensure_elasticsearch_index!
-          end
-          include_examples 'search results sorted' do
-            let(:results_created) { described_class.new(user, 'sorted', [project.id], sort: sort) }
-            let(:results_updated) { described_class.new(user, 'updated', [project.id], sort: sort) }
-          end
-          include_examples 'search results sorted by popularity' do
-            let(:results_popular) { described_class.new(user, 'popular', [project.id], sort: sort) }
-          end
-        end
+      let_it_be(:project) { create(:project, :public) }
+      let_it_be(:old_result) do
+        create(:work_item, project: project, title: 'sorted old', created_at: 1.month.ago)
+      end
+      let_it_be(:new_result) do
+        create(:work_item, project: project, title: 'sorted recent', created_at: 1.day.ago)
+      end
+      let_it_be(:very_old_result) do
+        create(:work_item, project: project, title: 'sorted very old', created_at: 1.year.ago)
+      end
+      let_it_be(:old_updated) do
+        create(:work_item, project: project, title: 'updated old', updated_at: 1.month.ago)
+      end
+      let_it_be(:new_updated) do
+        create(:work_item, project: project, title: 'updated recent', updated_at: 1.day.ago)
+      end
+      let_it_be(:very_old_updated) do
+        create(:work_item, project: project, title: 'updated very old', updated_at: 1.year.ago)
+      end
+      let_it_be(:less_popular_result) do
+        create(:work_item, project: project, title: 'less popular', upvotes_count: 10)
+      end
+      let_it_be(:non_popular_result) do
+        create(:work_item, project: project, title: 'non popular', upvotes_count: 1)
+      end
+      let_it_be(:popular_result) do
+        create(:work_item, project: project, title: 'popular', upvotes_count: 100)
+      end
+      before do
+        ::Elastic::ProcessInitialBookkeepingService.backfill_projects!(project)
+        ensure_elasticsearch_index!
+      end
+      include_examples 'search results sorted' do
+        let(:results_created) { described_class.new(user, 'sorted', [project.id], sort: sort) }
+        let(:results_updated) { described_class.new(user, 'updated', [project.id], sort: sort) }
+      end
+      include_examples 'search results sorted by popularity' do
+        let(:results_popular) { described_class.new(user, 'popular', [project.id], sort: sort) }
       end
     end
   end
   describe 'confidential issues', :elastic_delete_by_query do
-    [:work_item, :issue].each do |document_type|
-      context "when we have document_type as #{document_type}" do
-        let_it_be(:project_3) { create(:project, :public) }
-        let_it_be(:project_4) { create(:project, :public) }
-        let_it_be(:limit_project_ids) { [project_1.id, project_2.id, project_3.id] }
-        let_it_be(:author) { create(:user) }
-        let_it_be(:assignee) { create(:user) }
-        let_it_be(:non_member) { create(:user) }
-        let_it_be(:member) { create(:user) }
-        let_it_be(:admin) { create(:admin) }
-        let_it_be(:issue) { create(:issue, project: project_1, title: 'Issue 1', iid: 1) }
-        let_it_be(:security_issue_1) do
-          create(:issue, :confidential, project: project_1, title: 'Security issue 1', author: author, iid: 2)
-        end
-
-        let_it_be(:security_issue_2) do
-          create(:issue, :confidential, title: 'Security issue 2',
-            project: project_1, assignees: [assignee], iid: 3)
-        end
-        let_it_be(:security_issue_3) do
-          create(:issue, :confidential, project: project_2, title: 'Security issue 3', author: author, iid: 1)
-        end
-        let_it_be(:security_issue_4) do
-          create(:issue, :confidential, project: project_3,
-            title: 'Security issue 4', assignees: [assignee], iid: 1)
-        end
-        let_it_be(:security_issue_5) do
-          create(:issue, :confidential, project: project_4, title: 'Security issue 5', iid: 1)
-        end
-        before do
-          stub_feature_flags(search_issues_uses_work_items_index: (document_type == :work_item))
-          ::Elastic::ProcessInitialBookkeepingService.backfill_projects!(project_1, project_2, project_3, project_4)
-          ensure_elasticsearch_index!
-        end
-        context 'when searching by term' do
-          let(:query) { 'issue' }
-          it 'does not list confidential issues for guests' do
-            results = described_class.new(nil, query, limit_project_ids)
-            issues = results.objects('issues')
-            expect(issues).to contain_exactly(issue)
-            expect(results.issues_count).to eq 1
-          end
-          it 'does not list confidential issues for non project members' do
-            results = described_class.new(non_member, query, limit_project_ids)
-            issues = results.objects('issues')
-            expect(issues).to contain_exactly(issue)
-            expect(results.issues_count).to eq 1
-          end
-          it 'lists confidential issues for author' do
-            results = described_class.new(author, query, limit_project_ids)
-            issues = results.objects('issues')
-            expect(issues).to contain_exactly(issue, security_issue_1, security_issue_3)
-            expect(results.issues_count).to eq 3
-          end
-          it 'lists confidential issues for assignee' do
-            results = described_class.new(assignee, query, limit_project_ids)
-            issues = results.objects('issues')
-
-            expect(issues).to contain_exactly(issue, security_issue_2, security_issue_4)
-            expect(results.issues_count).to eq 3
-          end
-          it 'lists confidential issues for project members' do
-            project_1.add_developer(member)
-            project_2.add_developer(member)
-            results = described_class.new(member, query, limit_project_ids)
-            issues = results.objects('issues')
-            expect(issues).to contain_exactly(issue, security_issue_1, security_issue_2, security_issue_3)
-            expect(results.issues_count).to eq 4
-          end
-          context 'for admin users' do
-            context 'when admin mode enabled', :enable_admin_mode do
-              it 'lists all issues' do
-                results = described_class.new(admin, query, limit_project_ids)
-                issues = results.objects('issues')
-                expect(issues).to contain_exactly(issue, security_issue_1,
-                  security_issue_2, security_issue_3, security_issue_4, security_issue_5)
-                expect(results.issues_count).to eq 6
-              end
-            end
-            context 'when admin mode disabled' do
-              it 'does not list confidential issues' do
-                results = described_class.new(admin, query, limit_project_ids)
-                issues = results.objects('issues')
-                expect(issues).to contain_exactly(issue)
-                expect(results.issues_count).to eq 1
-              end
-            end
+    let_it_be(:project_3) { create(:project, :public) }
+    let_it_be(:project_4) { create(:project, :public) }
+    let_it_be(:limit_project_ids) { [project_1.id, project_2.id, project_3.id] }
+    let_it_be(:author) { create(:user) }
+    let_it_be(:assignee) { create(:user) }
+    let_it_be(:non_member) { create(:user) }
+    let_it_be(:member) { create(:user) }
+    let_it_be(:admin) { create(:admin) }
+    let_it_be(:issue) { create(:issue, project: project_1, title: 'Issue 1', iid: 1) }
+    let_it_be(:security_issue_1) do
+      create(:issue, :confidential, project: project_1, title: 'Security issue 1', author: author, iid: 2)
+    end
+    let_it_be(:security_issue_2) do
+      create(:issue, :confidential, title: 'Security issue 2',
+        project: project_1, assignees: [assignee], iid: 3)
+    end
+    let_it_be(:security_issue_3) do
+      create(:issue, :confidential, project: project_2, title: 'Security issue 3', author: author, iid: 1)
+    end
+    let_it_be(:security_issue_4) do
+      create(:issue, :confidential, project: project_3,
+        title: 'Security issue 4', assignees: [assignee], iid: 1)
+    end
+    let_it_be(:security_issue_5) do
+      create(:issue, :confidential, project: project_4, title: 'Security issue 5', iid: 1)
+    end
+    before do
+      ::Elastic::ProcessInitialBookkeepingService.backfill_projects!(project_1, project_2, project_3, project_4)
+      ensure_elasticsearch_index!
+    end
+    context 'when searching by term' do
+      let(:query) { 'issue' }
+      it 'does not list confidential issues for guests' do
+        results = described_class.new(nil, query, limit_project_ids)
+        issues = results.objects('issues')
+        expect(issues).to contain_exactly(issue)
+        expect(results.issues_count).to eq 1
+      end
+      it 'does not list confidential issues for non project members' do
+        results = described_class.new(non_member, query, limit_project_ids)
+        issues = results.objects('issues')
+        expect(issues).to contain_exactly(issue)
+        expect(results.issues_count).to eq 1
+      end
+      it 'lists confidential issues for author' do
+        results = described_class.new(author, query, limit_project_ids)
+        issues = results.objects('issues')
+        expect(issues).to contain_exactly(issue, security_issue_1, security_issue_3)
+        expect(results.issues_count).to eq 3
+      end
+      it 'lists confidential issues for assignee' do
+        results = described_class.new(assignee, query, limit_project_ids)
+        issues = results.objects('issues')
+        expect(issues).to contain_exactly(issue, security_issue_2, security_issue_4)
+        expect(results.issues_count).to eq 3
+      end
+      it 'lists confidential issues for project members' do
+        project_1.add_developer(member)
+        project_2.add_developer(member)
+        results = described_class.new(member, query, limit_project_ids)
+        issues = results.objects('issues')
+        expect(issues).to contain_exactly(issue, security_issue_1, security_issue_2, security_issue_3)
+        expect(results.issues_count).to eq 4
+      end
+      context 'for admin users' do
+        context 'when admin mode enabled', :enable_admin_mode do
+          it 'lists all issues' do
+            results = described_class.new(admin, query, limit_project_ids)
+            issues = results.objects('issues')
+            expect(issues).to contain_exactly(issue, security_issue_1,
+              security_issue_2, security_issue_3, security_issue_4, security_issue_5)
+            expect(results.issues_count).to eq 6
           end
         end
-        context 'when searching by iid' do
-          let(:query) { '#1' }
-
-          it 'does not list confidential issues for guests' do
-            results = described_class.new(nil, query, limit_project_ids)
+        context 'when admin mode disabled' do
+          it 'does not list confidential issues' do
+            results = described_class.new(admin, query, limit_project_ids)
             issues = results.objects('issues')
             expect(issues).to contain_exactly(issue)
             expect(results.issues_count).to eq 1
           end
-          it 'does not list confidential issues for non project members' do
-            results = described_class.new(non_member, query, limit_project_ids)
-            issues = results.objects('issues')
-            expect(issues).to contain_exactly(issue)
-            expect(results.issues_count).to eq 1
-          end
-          it 'lists confidential issues for author' do
-            results = described_class.new(author, query, limit_project_ids)
-            issues = results.objects('issues')
-            expect(issues).to contain_exactly(issue, security_issue_3)
-            expect(results.issues_count).to eq 2
-          end
-          it 'lists confidential issues for assignee' do
-            results = described_class.new(assignee, query, limit_project_ids)
-            issues = results.objects('issues')
-            expect(issues).to contain_exactly(issue, security_issue_4)
-            expect(results.issues_count).to eq 2
-          end
-          it 'lists confidential issues for project members' do
-            project_2.add_developer(member)
-            project_3.add_developer(member)
-            results = described_class.new(member, query, limit_project_ids)
-            issues = results.objects('issues')
-            expect(issues).to contain_exactly(issue, security_issue_3, security_issue_4)
-            expect(results.issues_count).to eq 3
-          end
-          context 'for admin users' do
-            context 'when admin mode enabled', :enable_admin_mode do
-              it 'lists all issues' do
-                results = described_class.new(admin, query, limit_project_ids)
-                issues = results.objects('issues')
-                expect(issues).to contain_exactly(issue, security_issue_3, security_issue_4, security_issue_5)
-                expect(results.issues_count).to eq 4
-              end
-            end
-            context 'when admin mode disabled' do
-              it 'does not list confidential issues' do
-                results = described_class.new(admin, query, limit_project_ids)
-                issues = results.objects('issues')
-                expect(issues).to contain_exactly(issue)
-                expect(results.issues_count).to eq 1
-              end
-            end
+        end
+      end
+    end
+    context 'when searching by iid' do
+      let(:query) { '#1' }
+      it 'does not list confidential issues for guests' do
+        results = described_class.new(nil, query, limit_project_ids)
+        issues = results.objects('issues')
+        expect(issues).to contain_exactly(issue)
+        expect(results.issues_count).to eq 1
+      end
+      it 'does not list confidential issues for non project members' do
+        results = described_class.new(non_member, query, limit_project_ids)
+        issues = results.objects('issues')
+        expect(issues).to contain_exactly(issue)
+        expect(results.issues_count).to eq 1
+      end
+      it 'lists confidential issues for author' do
+        results = described_class.new(author, query, limit_project_ids)
+        issues = results.objects('issues')
+        expect(issues).to contain_exactly(issue, security_issue_3)
+        expect(results.issues_count).to eq 2
+      end
+      it 'lists confidential issues for assignee' do
+        results = described_class.new(assignee, query, limit_project_ids)
+        issues = results.objects('issues')
+        expect(issues).to contain_exactly(issue, security_issue_4)
+        expect(results.issues_count).to eq 2
+      end
+      it 'lists confidential issues for project members' do
+        project_2.add_developer(member)
+        project_3.add_developer(member)
+        results = described_class.new(member, query, limit_project_ids)
+        issues = results.objects('issues')
+        expect(issues).to contain_exactly(issue, security_issue_3, security_issue_4)
+        expect(results.issues_count).to eq 3
+      end
+      context 'for admin users' do
+        context 'when admin mode enabled', :enable_admin_mode do
+          it 'lists all issues' do
+            results = described_class.new(admin, query, limit_project_ids)
+            issues = results.objects('issues')
+
+            expect(issues).to contain_exactly(issue, security_issue_3, security_issue_4, security_issue_5)
+            expect(results.issues_count).to eq 4
+          end
+        end
+
+        context 'when admin mode disabled' do
+          it 'does not list confidential issues' do
+            results = described_class.new(admin, query, limit_project_ids)
+            issues = results.objects('issues')
+
+            expect(issues).to contain_exactly(issue)
+            expect(results.issues_count).to eq 1
           end
         end
       end

ee/spec/requests/api/search_spec.rb

@@ -263,34 +263,29 @@ def results_paths
     end
     context 'for issues scope' do
-      [:work_item, :issue].each do |document_type|
-        context "when we have document_type as #{document_type}" do
-          before do
-            stub_feature_flags(search_issues_uses_work_items_index: (document_type == :work_item))
-            create_list(:issue, 2, project: project)
-            ensure_elasticsearch_index!
-          end
-
-          it 'avoids N+1 queries', :use_sql_query_cache do
-            control = ActiveRecord::QueryRecorder.new(skip_cached: false) do
-              get api(endpoint, user), params: { scope: 'issues', search: '*' }
-            end
-            create_list(:issue, 2, project: project)
-            create_list(:issue, 2, project: create(:project, group: group))
-            create_list(:issue, 2)
-            ensure_elasticsearch_index!
-            expect do
-              get api(endpoint, user), params: { scope: 'issues', search: '*' }
-            end.not_to exceed_query_limit(control)
-          end
-          it_behaves_like 'pagination', scope: 'issues'
-          it_behaves_like 'orderable by created_at', scope: 'issues'
-        end
+      before do
+        create_list(:issue, 2, project: project)
+        ensure_elasticsearch_index!
+      end
+      it 'avoids N+1 queries', :use_sql_query_cache do
+        control = ActiveRecord::QueryRecorder.new(skip_cached: false) do
+          get api(endpoint, user), params: { scope: 'issues', search: '*' }
+        end
+        create_list(:issue, 2, project: project)
+        create_list(:issue, 2, project: create(:project, group: group))
+        create_list(:issue, 2)
+        ensure_elasticsearch_index!
+        expect do
+          get api(endpoint, user), params: { scope: 'issues', search: '*' }
+        end.not_to exceed_query_limit(control)
       end
+
+      it_behaves_like 'pagination', scope: 'issues'
+      it_behaves_like 'orderable by created_at', scope: 'issues'
     end
     unless level == :project

ee/spec/services/search/global_service_spec.rb

@@ -177,23 +177,15 @@
     context 'on issue' do
       let(:scope) { 'issues' }
-      [:work_item, :issue].each do |document_type|
-        context "when we have document_type as #{document_type}" do
-          let!(:work_item) { create document_type, project: project }
-          let(:search) { work_item.title }
-          before do
-            stub_feature_flags(search_issues_uses_work_items_index: (document_type == :work_item))
-          end
-
-          where(:project_level, :feature_access_level, :membership, :admin_mode, :expected_count) do
-            permission_table_for_guest_feature_access
-          end
-          with_them do
-            it_behaves_like 'search respects visibility'
-          end
-        end
+      let!(:work_item) { create :work_item, project: project }
+      let(:search) { work_item.title }
+      where(:project_level, :feature_access_level, :membership, :admin_mode, :expected_count) do
+        permission_table_for_guest_feature_access
+      end
+      with_them do
+        it_behaves_like 'search respects visibility'
       end
     end

ee/spec/services/search/group_service_spec.rb

@@ -442,27 +442,21 @@
     context 'for issues' do
       let(:scope) { 'issues' }
-      [:work_item, :issue].each do |document_type|
-        context "when we have document_type as #{document_type}" do
-          let_it_be(:issue) { create(document_type, project: project) }
-          let_it_be(:issue2) { create(document_type, project: project2, title: issue.title) }
-          let(:search) { issue.title }
-
-          where(:project_level, :feature_access_level, :membership, :admin_mode, :expected_count) do
-            permission_table_for_guest_feature_access
-          end
-
-          with_them do
-            before do
-              stub_feature_flags(search_issues_uses_work_items_index: (document_type == :work_item))
-              Elastic::ProcessInitialBookkeepingService.track!(issue, issue2)
-              ensure_elasticsearch_index!
-            end
-            it_behaves_like 'search respects visibility'
-          end
+      let_it_be(:work_item) { create(:work_item, project: project) }
+      let_it_be(:work_item2) { create(:work_item, project: project2, title: work_item.title) }
+      let(:search) { work_item.title }
+      where(:project_level, :feature_access_level, :membership, :admin_mode, :expected_count) do
+        permission_table_for_guest_feature_access
+      end
+      with_them do
+        before do
+          Elastic::ProcessInitialBookkeepingService.track!(work_item, work_item2)
+          ensure_elasticsearch_index!
         end
+
+        it_behaves_like 'search respects visibility'
       end
     end
@@ -529,35 +523,29 @@
     context 'for issues' do
       let_it_be(:project) { create(:project, :public, group: group) }
-      let_it_be(:old_result) { create(:issue, project: project, title: 'sorted old', created_at: 1.month.ago) }
-      let_it_be(:new_result) { create(:issue, project: project, title: 'sorted recent', created_at: 1.day.ago) }
+      let_it_be(:old_result) { create(:work_item, project: project, title: 'sorted old', created_at: 1.month.ago) }
+      let_it_be(:new_result) { create(:work_item, project: project, title: 'sorted recent', created_at: 1.day.ago) }
       let_it_be(:very_old_result) do
-        create(:issue, project: project, title: 'sorted very old', created_at: 1.year.ago)
+        create(:work_item, project: project, title: 'sorted very old', created_at: 1.year.ago)
       end
-      let_it_be(:old_updated) { create(:issue, project: project, title: 'updated old', updated_at: 1.month.ago) }
-      let_it_be(:new_updated) { create(:issue, project: project, title: 'updated recent', updated_at: 1.day.ago) }
+      let_it_be(:old_updated) { create(:work_item, project: project, title: 'updated old', updated_at: 1.month.ago) }
+      let_it_be(:new_updated) { create(:work_item, project: project, title: 'updated recent', updated_at: 1.day.ago) }
       let_it_be(:very_old_updated) do
-        create(:issue, project: project, title: 'updated very old', updated_at: 1.year.ago)
+        create(:work_item, project: project, title: 'updated very old', updated_at: 1.year.ago)
       end
       let(:results_created) { described_class.new(nil, group, search: 'sorted', sort: sort).execute }
       let(:results_updated) { described_class.new(nil, group, search: 'updated', sort: sort).execute }
-      [:work_item, :issue].each do |document_type|
-        context "when we have document_type as #{document_type}" do
-          let(:scope) { 'issues' }
-
-          before do
-            stub_feature_flags(search_issues_uses_work_items_index: (document_type == :work_item))
-
-            Elastic::ProcessInitialBookkeepingService.backfill_projects!(project)
-            ensure_elasticsearch_index!
-          end
-          include_examples 'search results sorted'
-        end
+      let(:scope) { 'issues' }
+      before do
+        Elastic::ProcessInitialBookkeepingService.backfill_projects!(project)
+        ensure_elasticsearch_index!
       end
+
+      include_examples 'search results sorted'
     end
     context 'for merge requests' do

ee/spec/services/search/project_service_spec.rb

@@ -426,24 +426,16 @@
     context 'for issue' do
       let(:scope) { 'issues' }
-      [:work_item, :issue].each do |document_type|
-        context "when we have document_type as #{document_type}" do
-          let!(:issue) { create document_type, project: project }
-          let!(:issue2) { create document_type, project: project2, title: issue.title }
-          let(:search) { issue.title }
-          before do
-            stub_feature_flags(search_issues_uses_work_items_index: (document_type == :work_item))
-          end
-
-          where(:project_level, :feature_access_level, :membership, :admin_mode, :expected_count) do
-            permission_table_for_guest_feature_access
-          end
-          with_them do
-            it_behaves_like 'search respects visibility'
-          end
-        end
+      let!(:work_item) { create :work_item, project: project }
+      let!(:work_item2) { create :work_item, project: project2, title: work_item.title }
+      let(:search) { work_item.title }
+      where(:project_level, :feature_access_level, :membership, :admin_mode, :expected_count) do
+        permission_table_for_guest_feature_access
+      end
+      with_them do
+        it_behaves_like 'search respects visibility'
       end
     end
@@ -508,30 +500,25 @@
   context 'for sorting', :elastic_delete_by_query do
     context 'with issues' do
-      [:work_item, :issue].each do |document_type|
-        context "when we have document_type as #{document_type}" do
-          let(:scope) { 'issues' }
-
-          let!(:old_result) { create(:issue, project: project, title: 'sorted old', created_at: 1.month.ago) }
-          let!(:new_result) { create(:issue, project: project, title: 'sorted recent', created_at: 1.day.ago) }
-          let!(:very_old_result) { create(:issue, project: project, title: 'sorted very old', created_at: 1.year.ago) }
-
-          let!(:old_updated) { create(:issue, project: project, title: 'updated old', updated_at: 1.month.ago) }
-          let!(:new_updated) { create(:issue, project: project, title: 'updated recent', updated_at: 1.day.ago) }
-          let!(:very_old_updated) do
-            create(:issue, project: project, title: 'updated very old', updated_at: 1.year.ago)
-          end
-          before do
-            stub_feature_flags(search_issues_uses_work_items_index: (document_type == :work_item))
-            ensure_elasticsearch_index!
-          end
-          include_examples 'search results sorted' do
-            let(:results_created) { described_class.new(nil, project, search: 'sorted', sort: sort).execute }
-            let(:results_updated) { described_class.new(nil, project, search: 'updated', sort: sort).execute }
-          end
-        end
+      let(:scope) { 'issues' }
+      let!(:old_result) { create(:work_item, project: project, title: 'sorted old', created_at: 1.month.ago) }
+      let!(:new_result) { create(:work_item, project: project, title: 'sorted recent', created_at: 1.day.ago) }
+      let!(:very_old_result) { create(:work_item, project: project, title: 'sorted very old', created_at: 1.year.ago) }
+      let!(:old_updated) { create(:work_item, project: project, title: 'updated old', updated_at: 1.month.ago) }
+      let!(:new_updated) { create(:work_item, project: project, title: 'updated recent', updated_at: 1.day.ago) }
+      let!(:very_old_updated) do
+        create(:work_item, project: project, title: 'updated very old', updated_at: 1.year.ago)
+      end
+
+      before do
+        ensure_elasticsearch_index!
+      end
+
+      include_examples 'search results sorted' do
+        let(:results_created) { described_class.new(nil, project, search: 'sorted', sort: sort).execute }
+        let(:results_updated) { described_class.new(nil, project, search: 'updated', sort: sort).execute }
       end
     end

ee/spec/support/features/redacted_search_results_examples.rb

 # frozen_string_literal: true
-RSpec.shared_examples 'a redacted search results page' do |include_anonymous: true, document_type: :issue|
+RSpec.shared_examples 'a redacted search results page' do |include_anonymous: true|
   let(:public_group) { create(:group, :public) }
   let(:public_restricted_project) { create(:project, :repository, :public, :wiki_repo, namespace: public_group, name: 'The Project searchabletext') }
   let(:issue_access_level) { ProjectFeature::PRIVATE }
@@ -12,10 +12,10 @@
     Sidekiq::Testing.inline! do
       # Create a public project that the user is not member of.
       # And add some content to it.
-      issue = create(document_type, project: public_restricted_project, title: 'The Issue searchabletext')
-      create(:note, project: public_restricted_project, noteable: issue, note: 'A note on issue searchabletext')
-      confidential_issue = create(document_type, :confidential, project: public_restricted_project, title: 'The Confidential Issue searchabletext')
-      create(:note, project: public_restricted_project, noteable: confidential_issue, note: 'A note on confidential issue searchabletext')
+      work_item = create(:work_item, project: public_restricted_project, title: 'The Issue searchabletext')
+      create(:note, project: public_restricted_project, noteable: work_item, note: 'A note on work_item searchabletext')
+      confidential_work_item = create(:work_item, :confidential, project: public_restricted_project, title: 'The Confidential Issue searchabletext')
+      create(:note, project: public_restricted_project, noteable: confidential_work_item, note: 'A note on confidential work_item searchabletext')
       create(:milestone, project: public_restricted_project, title: 'The Milestone searchabletext')
       create(:note_on_commit, project: public_restricted_project, note: 'A note on commit searchabletext')
       create(:diff_note_on_commit, project: public_restricted_project, note: 'A note on diff on commit searchabletext')
@@ -65,12 +65,12 @@
         expect(page).to have_content('The Project')
       end
       # Issues scope is not available for search within a project when
-      # issues are restricted
+      # work_items are restricted
       if has_search_scope?('Issues')
         select_search_scope('Issues')
-        # Project issues are restricted
+        # Project work_items are restricted
         expect(page).not_to have_content('The Issue')
-        expect(page).not_to have_content('The Confidential issue')
+        expect(page).not_to have_content('The Confidential work_item')
       end
       # Merge requests scope is not available for search within a project when
@@ -82,10 +82,10 @@
       end
       # Milestones scope is not available for search within a project when
-      # issues are restricted
+      # work_items are restricted
       if has_search_scope?('Milestones')
         select_search_scope('Milestones')
-        # Project issues are restricted
+        # Project work_items are restricted
         expect(page).not_to have_content('The Milestone')
       end
@@ -96,7 +96,7 @@
       end
     end
-    context 'when issues are public', :elastic, :js, :disable_rate_limiter do
+    context 'when work_items are public', :elastic, :js, :disable_rate_limiter do
       let(:issue_access_level) { ProjectFeature::ENABLED }
       it 'redacts other private features' do
@@ -114,9 +114,9 @@
         end
         select_search_scope('Issues')
-        # Project issues are still public
+        # Project work_items are still public
         expect(page).to have_content('The Issue')
-        expect(page).not_to have_content('The Confidential issue')
+        expect(page).not_to have_content('The Confidential work_item')
         # Merge requests scope is not available for search within a project when
         # code is restricted
@@ -127,12 +127,12 @@
         end
         select_search_scope('Milestones')
-        # Project issues are still public
+        # Project work_items are still public
         expect(page).to have_content('The Milestone')
         select_search_scope('Comments')
         # All places where notes are posted are restricted
-        expect(page).to have_content('A note on issue')
+        expect(page).to have_content('A note on work_item')
         expect(page).to have_content('A note on', count: 1)
       end
     end

spec/support/helpers/user_with_namespace_shim.yml

@@ -101,7 +101,6 @@
 - ee/spec/features/remote_development/workspaces_dropdown_group_spec.rb
 - ee/spec/features/search/elastic/global_search_spec.rb
 - ee/spec/features/search/elastic/project_search_spec.rb
-- ee/spec/features/search/elastic/project_search_redactions_issue_spec.rb
 - ee/spec/features/search/elastic/project_search_redactions_work_item_spec.rb
 - ee/spec/features/search/elastic/snippet_search_spec.rb
 - ee/spec/features/security/dashboard_access_spec.rb