gitlab-org--gitlab-foss/spec/finders/user_recent_events_finder_spec.rb

# frozen_string_literal: true

require 'spec_helper'

RSpec.describe UserRecentEventsFinder do
  let_it_be(:project_owner, reload: true) { create(:user) }
  let_it_be(:current_user, reload: true)  { create(:user) }
  let_it_be(:private_project)  { create(:project, :private, creator: project_owner) }
  let_it_be(:internal_project) { create(:project, :internal, creator: project_owner) }
  let_it_be(:public_project)   { create(:project, :public, creator: project_owner) }
  let_it_be(:private_event)   { create(:event, project: private_project, author: project_owner) }
  let_it_be(:internal_event)  { create(:event, project: internal_project, author: project_owner) }
  let_it_be(:public_event)    { create(:event, project: public_project, author: project_owner) }
  let_it_be(:issue) { create(:issue, project: public_project) }

  let(:limit) { nil }
  let(:params) { { limit: limit } }

  subject(:finder) { described_class.new(current_user, project_owner, nil, params) }

  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
    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 }

      expect(finder.execute).to be_empty
    end

    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) }

      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) }

      it 'includes events from all users', :aggregate_failures do
        events = described_class.new(current_user, [project_owner, second_user], nil, params).execute

        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

            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)

        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

      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

        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

            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 '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')

          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

      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(push_event)
        expect(events.size).to eq(1)
      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

        expect(events).to include(merge_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

        expect(events).to include(issue_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

        expect(events).to include(comment_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

        expect(events).to include(wiki_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

        expect(events).to include(design_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

        expect(events).to include(private_event, internal_event, public_event, team_event)
        expect(events.size).to eq(4)
      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

        expect(events).to include(event_a)
        expect(events).to include(event_b)
      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 not set' do
        it 'returns events limited to DEFAULT_LIMIT' do
          expect(finder.execute.size).to eq(described_class::DEFAULT_LIMIT)
        end
      end

      context 'when limit is set' do
        let(:limit) { 2 }

        it 'returns events limited to specified limit' do
          expect(finder.execute.size).to eq(limit)
        end
      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
      end
    end
  end
end