Add latest changes from gitlab-org/gitlab@15-2-stable-eev15.2.0-rc42

10 files changed, 315 insertions, 207 deletions

diff --git a/spec/finders/autocomplete/users_finder_spec.rb b/spec/finders/autocomplete/users_finder_spec.rb
index 9b3421d1b4f..de031041e18 100644
--- a/spec/finders/autocomplete/users_finder_spec.rb
+++ b/spec/finders/autocomplete/users_finder_spec.rb
@@ -62,7 +62,7 @@ RSpec.describe Autocomplete::UsersFinder do
       let_it_be(:group) { create(:group, :public) }
 
       before_all do
-        group.add_users([user1], GroupMember::DEVELOPER)
+        group.add_members([user1], GroupMember::DEVELOPER)
       end
 
       it { is_expected.to match_array([user1]) }
diff --git a/spec/finders/branches_finder_spec.rb b/spec/finders/branches_finder_spec.rb
index 11b7ab08fb2..9314f616c44 100644
--- a/spec/finders/branches_finder_spec.rb
+++ b/spec/finders/branches_finder_spec.rb
@@ -181,17 +181,17 @@ RSpec.describe BranchesFinder do
         it 'filters branches' do
           result = subject
 
-          expect(result.map(&:name)).to eq(%w(feature_conflict fix))
+          expect(result.map(&:name)).to eq(%w(feature_conflict few-commits))
         end
       end
 
       context 'by next page_token and per_page' do
-        let(:params) { { page_token: 'fix', per_page: 2 } }
+        let(:params) { { page_token: 'few-commits', per_page: 2 } }
 
         it 'filters branches' do
           result = subject
 
-          expect(result.map(&:name)).to eq(%w(flatten-dir gitattributes))
+          expect(result.map(&:name)).to eq(%w(fix flatten-dir))
         end
       end
 
@@ -254,7 +254,7 @@ RSpec.describe BranchesFinder do
         it 'falls back to default execute and ignore paginations' do
           result = subject
 
-          expect(result.map(&:name)).to eq(%w(feature feature_conflict fix flatten-dir))
+          expect(result.map(&:name)).to eq(%w(feature feature_conflict few-commits fix flatten-dir))
         end
       end
     end
diff --git a/spec/finders/ci/runners_finder_spec.rb b/spec/finders/ci/runners_finder_spec.rb
index e7ec4f01995..aeab5a51766 100644
--- a/spec/finders/ci/runners_finder_spec.rb
+++ b/spec/finders/ci/runners_finder_spec.rb
@@ -49,6 +49,67 @@ RSpec.describe Ci::RunnersFinder do
           end
         end
 
+        context 'by upgrade status' do
+          let(:upgrade_status) {}
+
+          let_it_be(:runner1) { create(:ci_runner, version: 'a') }
+          let_it_be(:runner2) { create(:ci_runner, version: 'b') }
+          let_it_be(:runner3) { create(:ci_runner, version: 'c') }
+          let_it_be(:runner_version_recommended) do
+            create(:ci_runner_version, version: 'a', status: :recommended)
+          end
+
+          let_it_be(:runner_version_not_available) do
+            create(:ci_runner_version, version: 'b', status: :not_available)
+          end
+
+          let_it_be(:runner_version_available) do
+            create(:ci_runner_version, version: 'c', status: :available)
+          end
+
+          def execute
+            described_class.new(current_user: admin, params: { upgrade_status: upgrade_status }).execute
+          end
+
+          Ci::RunnerVersion.statuses.keys.map(&:to_sym).each do |status|
+            context "set to :#{status}" do
+              let(:upgrade_status) { status }
+
+              it "calls with_upgrade_status scope with corresponding :#{status} status" do
+                if [:available, :not_available, :recommended].include?(status)
+                  expected_result = Ci::Runner.with_upgrade_status(status)
+                end
+
+                expect(Ci::Runner).to receive(:with_upgrade_status).with(status).and_call_original
+
+                result = execute
+
+                expect(result).to match_array(expected_result) if expected_result
+              end
+            end
+          end
+
+          context 'set to an invalid value' do
+            let(:upgrade_status) { :some_invalid_status }
+
+            it 'does not call with_upgrade_status' do
+              expect(Ci::Runner).not_to receive(:with_upgrade_status)
+
+              expect(execute).to match_array(Ci::Runner.all)
+            end
+          end
+
+          context 'set to nil' do
+            let(:upgrade_status) { nil }
+
+            it 'does not call with_upgrade_status' do
+              expect(Ci::Runner).not_to receive(:with_upgrade_status)
+
+              expect(execute).to match_array(Ci::Runner.all)
+            end
+          end
+        end
+
         context 'by status' do
           Ci::Runner::AVAILABLE_STATUSES.each do |status|
             it "calls the corresponding :#{status} scope on Ci::Runner" do
diff --git a/spec/finders/contributed_projects_finder_spec.rb b/spec/finders/contributed_projects_finder_spec.rb
index 86d3e7f8f19..e8ce02122a1 100644
--- a/spec/finders/contributed_projects_finder_spec.rb
+++ b/spec/finders/contributed_projects_finder_spec.rb
@@ -23,9 +23,15 @@ RSpec.describe ContributedProjectsFinder do
   end
 
   describe 'activity without a current user' do
-    subject { finder.execute }
+    it 'does only return public projects' do
+      projects = finder.execute
+      expect(projects).to match_array([public_project])
+    end
 
-    it { is_expected.to match_array([public_project]) }
+    it 'does return all projects when visibility gets ignored' do
+      projects = finder.execute(ignore_visibility: true)
+      expect(projects).to match_array([private_project, internal_project, public_project])
+    end
   end
 
   describe 'activity with a current user' do
diff --git a/spec/finders/groups/user_groups_finder_spec.rb b/spec/finders/groups/user_groups_finder_spec.rb
index a4a9b8d16d0..9339741da79 100644
--- a/spec/finders/groups/user_groups_finder_spec.rb
+++ b/spec/finders/groups/user_groups_finder_spec.rb
@@ -9,6 +9,7 @@ RSpec.describe Groups::UserGroupsFinder do
     let_it_be(:private_maintainer_group) { create(:group, :private, name: 'b private maintainer', path: 'b-private-maintainer') }
     let_it_be(:public_developer_group) { create(:group, project_creation_level: nil, name: 'c public developer', path: 'c-public-developer') }
     let_it_be(:public_maintainer_group) { create(:group, name: 'a public maintainer', path: 'a-public-maintainer') }
+    let_it_be(:public_owner_group) { create(:group, name: 'a public owner', path: 'a-public-owner') }
 
     subject { described_class.new(current_user, target_user, arguments).execute }
 
@@ -21,12 +22,14 @@ RSpec.describe Groups::UserGroupsFinder do
       private_maintainer_group.add_maintainer(user)
       public_developer_group.add_developer(user)
       public_maintainer_group.add_maintainer(user)
+      public_owner_group.add_owner(user)
     end
 
     it 'returns all groups where the user is a direct member' do
       is_expected.to match(
         [
           public_maintainer_group,
+          public_owner_group,
           private_maintainer_group,
           public_developer_group,
           guest_group
@@ -53,6 +56,7 @@ RSpec.describe Groups::UserGroupsFinder do
         is_expected.to match(
           [
             public_maintainer_group,
+            public_owner_group,
             private_maintainer_group,
             public_developer_group
           ]
@@ -73,6 +77,32 @@ RSpec.describe Groups::UserGroupsFinder do
       end
     end
 
+    context 'when permission is :transfer_projects' do
+      let(:arguments) { { permission_scope: :transfer_projects } }
+
+      specify do
+        is_expected.to match(
+          [
+            public_maintainer_group,
+            public_owner_group,
+            private_maintainer_group
+          ]
+        )
+      end
+
+      context 'when search is provided' do
+        let(:arguments) { { permission_scope: :transfer_projects, search: 'owner' } }
+
+        specify do
+          is_expected.to match(
+            [
+              public_owner_group
+            ]
+          )
+        end
+      end
+    end
+
     context 'when search is provided' do
       let(:arguments) { { search: 'maintainer' } }
 
diff --git a/spec/finders/joined_groups_finder_spec.rb b/spec/finders/joined_groups_finder_spec.rb
index 058db735708..feb1b11d159 100644
--- a/spec/finders/joined_groups_finder_spec.rb
+++ b/spec/finders/joined_groups_finder_spec.rb
@@ -45,7 +45,7 @@ RSpec.describe JoinedGroupsFinder do
       context 'if profile visitor is in one of the private group projects' do
         before do
           project = create(:project, :private, group: private_group, name: 'B', path: 'B')
-          project.add_user(profile_visitor, Gitlab::Access::DEVELOPER)
+          project.add_member(profile_visitor, Gitlab::Access::DEVELOPER)
         end
 
         it 'shows group' do
diff --git a/spec/finders/packages/conan/package_finder_spec.rb b/spec/finders/packages/conan/package_finder_spec.rb
index 6848786818b..f25a62225a8 100644
--- a/spec/finders/packages/conan/package_finder_spec.rb
+++ b/spec/finders/packages/conan/package_finder_spec.rb
@@ -45,7 +45,7 @@ RSpec.describe ::Packages::Conan::PackageFinder do
 
       before do
         project.update_column(:visibility_level, Gitlab::VisibilityLevel.string_options[visibility.to_s])
-        project.add_user(user, role) unless role == :anonymous
+        project.add_member(user, role) unless role == :anonymous
       end
 
       it { is_expected.to eq(expected_packages) }
diff --git a/spec/finders/packages/group_packages_finder_spec.rb b/spec/finders/packages/group_packages_finder_spec.rb
index 954db6481cd..90a8cd3c57f 100644
--- a/spec/finders/packages/group_packages_finder_spec.rb
+++ b/spec/finders/packages/group_packages_finder_spec.rb
@@ -98,8 +98,8 @@ RSpec.describe Packages::GroupPackagesFinder do
               )
 
               unless role == :anonymous
-                project.add_user(user, role)
-                subproject.add_user(user, role)
+                project.add_member(user, role)
+                subproject.add_member(user, role)
               end
             end
 
diff --git a/spec/finders/projects_finder_spec.rb b/spec/finders/projects_finder_spec.rb
index d26180bbf94..3bef4d85b33 100644
--- a/spec/finders/projects_finder_spec.rb
+++ b/spec/finders/projects_finder_spec.rb
@@ -177,6 +177,35 @@ RSpec.describe ProjectsFinder do
         end
       end
 
+      describe 'filter by topic_id' do
+        let_it_be(:topic1) { create(:topic) }
+        let_it_be(:topic2) { create(:topic) }
+
+        before do
+          public_project.reload
+          public_project.topics << topic1
+          public_project.save!
+        end
+
+        context 'topic with assigned projects' do
+          let(:params) { { topic_id: topic1.id } }
+
+          it { is_expected.to eq([public_project]) }
+        end
+
+        context 'topic without assigned projects' do
+          let(:params) { { topic_id: topic2.id } }
+
+          it { is_expected.to eq([]) }
+        end
+
+        context 'non-existing topic' do
+          let(:params) { { topic_id: non_existing_record_id } }
+
+          it { is_expected.to eq([]) }
+        end
+      end
+
       describe 'filter by personal' do
         let!(:personal_project) { create(:project, namespace: user.namespace) }
         let(:params) { { personal: true } }
diff --git a/spec/finders/user_recent_events_finder_spec.rb b/spec/finders/user_recent_events_finder_spec.rb
index d7f7bb9cebe..dbd52ec4d18 100644
--- a/spec/finders/user_recent_events_finder_spec.rb
+++ b/spec/finders/user_recent_events_finder_spec.rb
@@ -18,266 +18,248 @@ RSpec.describe UserRecentEventsFinder do
 
   subject(:finder) { described_class.new(current_user, project_owner, nil, params) }
 
-  shared_examples 'UserRecentEventsFinder examples' do
-    describe '#execute' do
-      context 'when profile is public' do
-        it 'returns all the events' do
-          expect(finder.execute).to include(private_event, internal_event, public_event)
-        end
-      end
-
-      context 'when profile is private' do
-        it 'returns no event' do
-          allow(Ability).to receive(:allowed?).and_call_original
-          allow(Ability).to receive(:allowed?).with(current_user, :read_user_profile, project_owner).and_return(false)
-
-          expect(finder.execute).to be_empty
-        end
+  describe '#execute' do
+    context 'when profile is public' do
+      it 'returns all the events' do
+        expect(finder.execute).to include(private_event, internal_event, public_event)
       end
+    end
 
-      it 'does not include the events if the user cannot read cross project' do
+    context 'when profile is private' do
+      it 'returns no event' do
         allow(Ability).to receive(:allowed?).and_call_original
-        expect(Ability).to receive(:allowed?).with(current_user, :read_cross_project) { false }
+        allow(Ability).to receive(:allowed?).with(current_user, :read_user_profile, project_owner).and_return(false)
 
         expect(finder.execute).to be_empty
       end
+    end
+
+    it 'does not include the events if the user cannot read cross project' do
+      allow(Ability).to receive(:allowed?).and_call_original
+      expect(Ability).to receive(:allowed?).with(current_user, :read_cross_project) { false }
 
-      context 'events from multiple users' do
-        let_it_be(:second_user, reload: true) { create(:user) }
-        let_it_be(:private_project_second_user) { create(:project, :private, creator: second_user) }
+      expect(finder.execute).to be_empty
+    end
 
-        let_it_be(:internal_project_second_user) { create(:project, :internal, creator: second_user) }
-        let_it_be(:public_project_second_user)   { create(:project, :public, creator: second_user) }
-        let_it_be(:private_event_second_user)   { create(:event, project: private_project_second_user, author: second_user) }
-        let_it_be(:internal_event_second_user)  { create(:event, project: internal_project_second_user, author: second_user) }
-        let_it_be(:public_event_second_user)    { create(:event, project: public_project_second_user, author: second_user) }
+    context 'events from multiple users' do
+      let_it_be(:second_user, reload: true) { create(:user) }
+      let_it_be(:private_project_second_user) { create(:project, :private, creator: second_user) }
 
-        it 'includes events from all users', :aggregate_failures do
-          events = described_class.new(current_user, [project_owner, second_user], nil, params).execute
+      let_it_be(:internal_project_second_user) { create(:project, :internal, creator: second_user) }
+      let_it_be(:public_project_second_user)   { create(:project, :public, creator: second_user) }
+      let_it_be(:private_event_second_user)   { create(:event, project: private_project_second_user, author: second_user) }
+      let_it_be(:internal_event_second_user)  { create(:event, project: internal_project_second_user, author: second_user) }
+      let_it_be(:public_event_second_user)    { create(:event, project: public_project_second_user, author: second_user) }
 
-          expect(events).to include(private_event, internal_event, public_event)
-          expect(events).to include(private_event_second_user, internal_event_second_user, public_event_second_user)
-          expect(events.size).to eq(6)
-        end
+      it 'includes events from all users', :aggregate_failures do
+        events = described_class.new(current_user, [project_owner, second_user], nil, params).execute
 
-        context 'selected events' do
-          using RSpec::Parameterized::TableSyntax
-
-          let_it_be(:push_event1) { create(:push_event, project: public_project, author: project_owner) }
-          let_it_be(:push_event2) { create(:push_event, project: public_project_second_user, author: second_user) }
-          let_it_be(:merge_event1) { create(:event, :merged, target_type: MergeRequest.to_s, project: public_project, author: project_owner) }
-          let_it_be(:merge_event2) { create(:event, :merged, target_type: MergeRequest.to_s, project: public_project_second_user, author: second_user) }
-          let_it_be(:comment_event1) { create(:event, :commented, target_type: Note.to_s, project: public_project, author: project_owner) }
-          let_it_be(:comment_event2) { create(:event, :commented, target_type: DiffNote.to_s, project: public_project, author: project_owner) }
-          let_it_be(:comment_event3) { create(:event, :commented, target_type: DiscussionNote.to_s, project: public_project_second_user, author: second_user) }
-          let_it_be(:issue_event1) { create(:event, :created, project: public_project, target: issue, author: project_owner) }
-          let_it_be(:issue_event2) { create(:event, :updated, project: public_project, target: issue, author: project_owner) }
-          let_it_be(:issue_event3) { create(:event, :closed, project: public_project_second_user, target: issue, author: second_user) }
-          let_it_be(:wiki_event1) { create(:wiki_page_event, project: public_project, author: project_owner) }
-          let_it_be(:wiki_event2) { create(:wiki_page_event, project: public_project_second_user, author: second_user) }
-          let_it_be(:design_event1) { create(:design_event, project: public_project, author: project_owner) }
-          let_it_be(:design_event2) { create(:design_updated_event, project: public_project_second_user, author: second_user) }
-
-          where(:event_filter, :ordered_expected_events) do
-            EventFilter.new(EventFilter::PUSH)     | lazy { [push_event1, push_event2] }
-            EventFilter.new(EventFilter::MERGED)   | lazy { [merge_event1, merge_event2] }
-            EventFilter.new(EventFilter::COMMENTS) | lazy { [comment_event1, comment_event2, comment_event3] }
-            EventFilter.new(EventFilter::TEAM)     | lazy { [private_event, internal_event, public_event, private_event_second_user, internal_event_second_user, public_event_second_user] }
-            EventFilter.new(EventFilter::ISSUE)    | lazy { [issue_event1, issue_event2, issue_event3] }
-            EventFilter.new(EventFilter::WIKI)     | lazy { [wiki_event1, wiki_event2] }
-            EventFilter.new(EventFilter::DESIGNS)  | lazy { [design_event1, design_event2] }
-          end
+        expect(events).to include(private_event, internal_event, public_event)
+        expect(events).to include(private_event_second_user, internal_event_second_user, public_event_second_user)
+        expect(events.size).to eq(6)
+      end
+
+      context 'selected events' do
+        using RSpec::Parameterized::TableSyntax
+
+        let_it_be(:push_event1) { create(:push_event, project: public_project, author: project_owner) }
+        let_it_be(:push_event2) { create(:push_event, project: public_project_second_user, author: second_user) }
+        let_it_be(:merge_event1) { create(:event, :merged, target_type: MergeRequest.to_s, project: public_project, author: project_owner) }
+        let_it_be(:merge_event2) { create(:event, :merged, target_type: MergeRequest.to_s, project: public_project_second_user, author: second_user) }
+        let_it_be(:comment_event1) { create(:event, :commented, target_type: Note.to_s, project: public_project, author: project_owner) }
+        let_it_be(:comment_event2) { create(:event, :commented, target_type: DiffNote.to_s, project: public_project, author: project_owner) }
+        let_it_be(:comment_event3) { create(:event, :commented, target_type: DiscussionNote.to_s, project: public_project_second_user, author: second_user) }
+        let_it_be(:issue_event1) { create(:event, :created, project: public_project, target: issue, author: project_owner) }
+        let_it_be(:issue_event2) { create(:event, :updated, project: public_project, target: issue, author: project_owner) }
+        let_it_be(:issue_event3) { create(:event, :closed, project: public_project_second_user, target: issue, author: second_user) }
+        let_it_be(:wiki_event1) { create(:wiki_page_event, project: public_project, author: project_owner) }
+        let_it_be(:wiki_event2) { create(:wiki_page_event, project: public_project_second_user, author: second_user) }
+        let_it_be(:design_event1) { create(:design_event, project: public_project, author: project_owner) }
+        let_it_be(:design_event2) { create(:design_updated_event, project: public_project_second_user, author: second_user) }
+
+        where(:event_filter, :ordered_expected_events) do
+          EventFilter.new(EventFilter::PUSH)     | lazy { [push_event1, push_event2] }
+          EventFilter.new(EventFilter::MERGED)   | lazy { [merge_event1, merge_event2] }
+          EventFilter.new(EventFilter::COMMENTS) | lazy { [comment_event1, comment_event2, comment_event3] }
+          EventFilter.new(EventFilter::TEAM)     | lazy { [private_event, internal_event, public_event, private_event_second_user, internal_event_second_user, public_event_second_user] }
+          EventFilter.new(EventFilter::ISSUE)    | lazy { [issue_event1, issue_event2, issue_event3] }
+          EventFilter.new(EventFilter::WIKI)     | lazy { [wiki_event1, wiki_event2] }
+          EventFilter.new(EventFilter::DESIGNS)  | lazy { [design_event1, design_event2] }
+        end
 
-          with_them do
-            it 'only returns selected events from all users (id DESC)' do
-              events = described_class.new(current_user, [project_owner, second_user], event_filter, params).execute
+        with_them do
+          it 'only returns selected events from all users (id DESC)' do
+            events = described_class.new(current_user, [project_owner, second_user], event_filter, params).execute
 
-              expect(events).to eq(ordered_expected_events.reverse)
-            end
+            expect(events).to eq(ordered_expected_events.reverse)
           end
         end
+      end
 
-        it 'does not include events from users with private profile', :aggregate_failures do
-          allow(Ability).to receive(:allowed?).and_call_original
-          allow(Ability).to receive(:allowed?).with(current_user, :read_user_profile, second_user).and_return(false)
+      it 'does not include events from users with private profile', :aggregate_failures do
+        allow(Ability).to receive(:allowed?).and_call_original
+        allow(Ability).to receive(:allowed?).with(current_user, :read_user_profile, second_user).and_return(false)
 
-          events = described_class.new(current_user, [project_owner, second_user], nil, params).execute
+        events = described_class.new(current_user, [project_owner, second_user], nil, params).execute
 
-          expect(events).to contain_exactly(private_event, internal_event, public_event)
-        end
+        expect(events).to contain_exactly(private_event, internal_event, public_event)
+      end
 
-        context 'with pagination params' do
-          using RSpec::Parameterized::TableSyntax
+      context 'with pagination params' do
+        using RSpec::Parameterized::TableSyntax
 
-          where(:limit, :offset, :ordered_expected_events) do
-            nil | nil   | lazy { [public_event_second_user, internal_event_second_user, private_event_second_user, public_event, internal_event, private_event] }
-            2   | nil   | lazy { [public_event_second_user, internal_event_second_user] }
-            nil | 4     | lazy { [internal_event, private_event] }
-            2   | 2     | lazy { [private_event_second_user, public_event] }
-          end
+        where(:limit, :offset, :ordered_expected_events) do
+          nil | nil   | lazy { [public_event_second_user, internal_event_second_user, private_event_second_user, public_event, internal_event, private_event] }
+          2   | nil   | lazy { [public_event_second_user, internal_event_second_user] }
+          nil | 4     | lazy { [internal_event, private_event] }
+          2   | 2     | lazy { [private_event_second_user, public_event] }
+        end
 
-          with_them do
-            let(:params) { { limit: limit, offset: offset }.compact }
+        with_them do
+          let(:params) { { limit: limit, offset: offset }.compact }
 
-            it 'returns paginated events sorted by id (DESC)' do
-              events = described_class.new(current_user, [project_owner, second_user], nil, params).execute
+          it 'returns paginated events sorted by id (DESC)' do
+            events = described_class.new(current_user, [project_owner, second_user], nil, params).execute
 
-              expect(events).to eq(ordered_expected_events)
-            end
+            expect(events).to eq(ordered_expected_events)
           end
         end
       end
+    end
+
+    context 'filter activity events' do
+      let_it_be(:push_event) { create(:push_event, project: public_project, author: project_owner) }
+      let_it_be(:merge_event) { create(:event, :merged, project: public_project, author: project_owner) }
+      let_it_be(:issue_event) { create(:event, :closed, project: public_project, target: issue, author: project_owner) }
+      let_it_be(:comment_event) { create(:event, :commented, project: public_project, author: project_owner) }
+      let_it_be(:wiki_event) { create(:wiki_page_event, project: public_project, author: project_owner) }
+      let_it_be(:design_event) { create(:design_event, project: public_project, author: project_owner) }
+      let_it_be(:team_event) { create(:event, :joined, project: public_project, author: project_owner) }
+
+      it 'includes all events', :aggregate_failures do
+        event_filter = EventFilter.new(EventFilter::ALL)
+        events = described_class.new(current_user, project_owner, event_filter, params).execute
+
+        expect(events).to include(private_event, internal_event, public_event)
+        expect(events).to include(push_event, merge_event, issue_event, comment_event, wiki_event, design_event, team_event)
+        expect(events.size).to eq(10)
+      end
 
-      context 'filter activity events' do
-        let_it_be(:push_event) { create(:push_event, project: public_project, author: project_owner) }
-        let_it_be(:merge_event) { create(:event, :merged, project: public_project, author: project_owner) }
-        let_it_be(:issue_event) { create(:event, :closed, project: public_project, target: issue, author: project_owner) }
-        let_it_be(:comment_event) { create(:event, :commented, project: public_project, author: project_owner) }
-        let_it_be(:wiki_event) { create(:wiki_page_event, project: public_project, author: project_owner) }
-        let_it_be(:design_event) { create(:design_event, project: public_project, author: project_owner) }
-        let_it_be(:team_event) { create(:event, :joined, project: public_project, author: project_owner) }
+      context 'when unknown filter is given' do
+        it 'includes returns all events', :aggregate_failures do
+          event_filter = EventFilter.new('unknown')
+          allow(event_filter).to receive(:filter).and_return('unknown')
 
-        it 'includes all events', :aggregate_failures do
-          event_filter = EventFilter.new(EventFilter::ALL)
-          events = described_class.new(current_user, project_owner, event_filter, params).execute
+          events = described_class.new(current_user, [project_owner], event_filter, params).execute
 
           expect(events).to include(private_event, internal_event, public_event)
           expect(events).to include(push_event, merge_event, issue_event, comment_event, wiki_event, design_event, team_event)
           expect(events.size).to eq(10)
         end
+      end
 
-        context 'when unknown filter is given' do
-          it 'includes returns all events', :aggregate_failures do
-            event_filter = EventFilter.new('unknown')
-            allow(event_filter).to receive(:filter).and_return('unknown')
+      it 'only includes push events', :aggregate_failures do
+        event_filter = EventFilter.new(EventFilter::PUSH)
+        events = described_class.new(current_user, project_owner, event_filter, params).execute
 
-            events = described_class.new(current_user, [project_owner], event_filter, params).execute
+        expect(events).to include(push_event)
+        expect(events.size).to eq(1)
+      end
 
-            expect(events).to include(private_event, internal_event, public_event)
-            expect(events).to include(push_event, merge_event, issue_event, comment_event, wiki_event, design_event, team_event)
-            expect(events.size).to eq(10)
-          end
-        end
+      it 'only includes merge events', :aggregate_failures do
+        event_filter = EventFilter.new(EventFilter::MERGED)
+        events = described_class.new(current_user, project_owner, event_filter, params).execute
 
-        it 'only includes push events', :aggregate_failures do
-          event_filter = EventFilter.new(EventFilter::PUSH)
-          events = described_class.new(current_user, project_owner, event_filter, params).execute
+        expect(events).to include(merge_event)
+        expect(events.size).to eq(1)
+      end
 
-          expect(events).to include(push_event)
-          expect(events.size).to eq(1)
-        end
+      it 'only includes issue events', :aggregate_failures do
+        event_filter = EventFilter.new(EventFilter::ISSUE)
+        events = described_class.new(current_user, project_owner, event_filter, params).execute
 
-        it 'only includes merge events', :aggregate_failures do
-          event_filter = EventFilter.new(EventFilter::MERGED)
-          events = described_class.new(current_user, project_owner, event_filter, params).execute
+        expect(events).to include(issue_event)
+        expect(events.size).to eq(1)
+      end
 
-          expect(events).to include(merge_event)
-          expect(events.size).to eq(1)
-        end
+      it 'only includes comments events', :aggregate_failures do
+        event_filter = EventFilter.new(EventFilter::COMMENTS)
+        events = described_class.new(current_user, project_owner, event_filter, params).execute
 
-        it 'only includes issue events', :aggregate_failures do
-          event_filter = EventFilter.new(EventFilter::ISSUE)
-          events = described_class.new(current_user, project_owner, event_filter, params).execute
+        expect(events).to include(comment_event)
+        expect(events.size).to eq(1)
+      end
 
-          expect(events).to include(issue_event)
-          expect(events.size).to eq(1)
-        end
+      it 'only includes wiki events', :aggregate_failures do
+        event_filter = EventFilter.new(EventFilter::WIKI)
+        events = described_class.new(current_user, project_owner, event_filter, params).execute
 
-        it 'only includes comments events', :aggregate_failures do
-          event_filter = EventFilter.new(EventFilter::COMMENTS)
-          events = described_class.new(current_user, project_owner, event_filter, params).execute
+        expect(events).to include(wiki_event)
+        expect(events.size).to eq(1)
+      end
 
-          expect(events).to include(comment_event)
-          expect(events.size).to eq(1)
-        end
+      it 'only includes design events', :aggregate_failures do
+        event_filter = EventFilter.new(EventFilter::DESIGNS)
+        events = described_class.new(current_user, project_owner, event_filter, params).execute
 
-        it 'only includes wiki events', :aggregate_failures do
-          event_filter = EventFilter.new(EventFilter::WIKI)
-          events = described_class.new(current_user, project_owner, event_filter, params).execute
+        expect(events).to include(design_event)
+        expect(events.size).to eq(1)
+      end
 
-          expect(events).to include(wiki_event)
-          expect(events.size).to eq(1)
-        end
+      it 'only includes team events', :aggregate_failures do
+        event_filter = EventFilter.new(EventFilter::TEAM)
+        events = described_class.new(current_user, project_owner, event_filter, params).execute
 
-        it 'only includes design events', :aggregate_failures do
-          event_filter = EventFilter.new(EventFilter::DESIGNS)
-          events = described_class.new(current_user, project_owner, event_filter, params).execute
+        expect(events).to include(private_event, internal_event, public_event, team_event)
+        expect(events.size).to eq(4)
+      end
+    end
 
-          expect(events).to include(design_event)
-          expect(events.size).to eq(1)
-        end
+    describe 'issue activity events' do
+      let(:issue) { create(:issue, project: public_project) }
+      let(:note) { create(:note_on_issue, noteable: issue, project: public_project) }
+      let!(:event_a) { create(:event, :commented, target: note, author: project_owner) }
+      let!(:event_b) { create(:event, :closed, target: issue, author: project_owner) }
 
-        it 'only includes team events', :aggregate_failures do
-          event_filter = EventFilter.new(EventFilter::TEAM)
-          events = described_class.new(current_user, project_owner, event_filter, params).execute
+      it 'includes all issue related events', :aggregate_failures do
+        events = finder.execute
 
-          expect(events).to include(private_event, internal_event, public_event, team_event)
-          expect(events.size).to eq(4)
-        end
+        expect(events).to include(event_a)
+        expect(events).to include(event_b)
       end
+    end
 
-      describe 'issue activity events' do
-        let(:issue) { create(:issue, project: public_project) }
-        let(:note) { create(:note_on_issue, noteable: issue, project: public_project) }
-        let!(:event_a) { create(:event, :commented, target: note, author: project_owner) }
-        let!(:event_b) { create(:event, :closed, target: issue, author: project_owner) }
-
-        it 'includes all issue related events', :aggregate_failures do
-          events = finder.execute
+    context 'limits' do
+      before do
+        stub_const("#{described_class}::DEFAULT_LIMIT", 1)
+        stub_const("#{described_class}::MAX_LIMIT", 3)
+      end
 
-          expect(events).to include(event_a)
-          expect(events).to include(event_b)
+      context 'when limit is not set' do
+        it 'returns events limited to DEFAULT_LIMIT' do
+          expect(finder.execute.size).to eq(described_class::DEFAULT_LIMIT)
         end
       end
 
-      context 'limits' do
-        before do
-          stub_const("#{described_class}::DEFAULT_LIMIT", 1)
-          stub_const("#{described_class}::MAX_LIMIT", 3)
-        end
+      context 'when limit is set' do
+        let(:limit) { 2 }
 
-        context 'when limit is not set' do
-          it 'returns events limited to DEFAULT_LIMIT' do
-            expect(finder.execute.size).to eq(described_class::DEFAULT_LIMIT)
-          end
+        it 'returns events limited to specified limit' do
+          expect(finder.execute.size).to eq(limit)
         end
+      end
 
-        context 'when limit is set' do
-          let(:limit) { 2 }
+      context 'when limit is set to a number that exceeds maximum limit' do
+        let(:limit) { 4 }
 
-          it 'returns events limited to specified limit' do
-            expect(finder.execute.size).to eq(limit)
-          end
+        before do
+          create(:event, project: public_project, author: project_owner)
         end
 
-        context 'when limit is set to a number that exceeds maximum limit' do
-          let(:limit) { 4 }
-
-          before do
-            create(:event, project: public_project, author: project_owner)
-          end
-
-          it 'returns events limited to MAX_LIMIT' do
-            expect(finder.execute.size).to eq(described_class::MAX_LIMIT)
-          end
+        it 'returns events limited to MAX_LIMIT' do
+          expect(finder.execute.size).to eq(described_class::MAX_LIMIT)
         end
       end
     end
   end
-
-  context 'when the optimized_followed_users_queries FF is on' do
-    before do
-      stub_feature_flags(optimized_followed_users_queries: true)
-    end
-
-    it_behaves_like 'UserRecentEventsFinder examples'
-  end
-
-  context 'when the optimized_followed_users_queries FF is off' do
-    before do
-      stub_feature_flags(optimized_followed_users_queries: false)
-    end
-
-    it_behaves_like 'UserRecentEventsFinder examples'
-  end
 end