debian-mirror-gitlab/spec/presenters/merge_request_presenter_spec.rb

# frozen_string_literal: true

require 'spec_helper'

RSpec.describe MergeRequestPresenter do
  let_it_be(:project) { create(:project, :repository) }
  let(:resource) { create(:merge_request, source_project: project) }

  let_it_be(:user) { create(:user) }

  describe '#mergeable_discussions_state' do
    subject { described_class.new(resource).mergeable_discussions_state }

    let(:discussions_state) { double }

    before do
      allow(resource).to receive(:mergeable_discussions_state?).and_return(discussions_state)
    end

    it 'returns the mergeable_discussions_state' do
      is_expected.to eq(discussions_state)
    end
  end

  describe '#ci_status' do
    subject { described_class.new(resource).ci_status }

    context 'when no head pipeline' do
      it 'return status from Ci integration' do
        ci_integration = double(Integrations::MockCi)
        ci_status = double

        allow(resource.source_project)
          .to receive(:ci_integration)
          .and_return(ci_integration)

        allow(resource).to receive(:head_pipeline).and_return(nil)

        expect(ci_integration).to receive(:commit_status)
          .with(resource.diff_head_sha, resource.source_branch)
          .and_return(ci_status)

        is_expected.to eq(ci_status)
      end
    end

    context 'when head pipeline present' do
      let(:pipeline) { build_stubbed(:ci_pipeline) }

      before do
        allow(resource).to receive(:actual_head_pipeline).and_return(pipeline)
      end

      context 'success with warnings' do
        before do
          allow(pipeline).to receive(:success?) { true }
          allow(pipeline).to receive(:has_warnings?) { true }
        end

        it 'returns "success-with-warnings"' do
          is_expected.to eq('success-with-warnings')
        end
      end

      context 'pipeline HAS status AND its not success with warnings' do
        before do
          allow(pipeline).to receive(:success?) { false }
          allow(pipeline).to receive(:has_warnings?) { false }
        end

        it 'returns pipeline status' do
          is_expected.to eq('pending')
        end
      end

      context 'pipeline has NO status AND its not success with warnings' do
        before do
          allow(pipeline).to receive(:status) { nil }
          allow(pipeline).to receive(:success?) { false }
          allow(pipeline).to receive(:has_warnings?) { false }
        end

        it 'returns "preparing"' do
          is_expected.to eq('preparing')
        end
      end
    end
  end

  describe '#conflict_resolution_path' do
    let(:presenter) { described_class.new(resource, current_user: user) }
    let(:path) { presenter.conflict_resolution_path }

    context 'when MR cannot be resolved in UI' do
      it 'does not return conflict resolution path' do
        allow(presenter).to receive_message_chain(:conflicts, :can_be_resolved_in_ui?) { false }

        expect(path).to be_nil
      end
    end

    context 'when conflicts cannot be resolved by user' do
      it 'does not return conflict resolution path' do
        allow(presenter).to receive_message_chain(:conflicts, :can_be_resolved_in_ui?) { true }
        allow(presenter).to receive_message_chain(:conflicts, :can_be_resolved_by?).with(user) { false }

        expect(path).to be_nil
      end
    end

    context 'when able to access conflict resolution UI' do
      it 'does return conflict resolution path' do
        allow(presenter).to receive_message_chain(:conflicts, :can_be_resolved_in_ui?) { true }
        allow(presenter).to receive_message_chain(:conflicts, :can_be_resolved_by?).with(user) { true }

        expect(path)
          .to eq("/#{project.full_path}/-/merge_requests/#{resource.iid}/conflicts")
      end
    end
  end

  context 'issues links' do
    let_it_be(:project) { create(:project, :private, :repository, creator: user, namespace: user.namespace) }
    let_it_be(:issue_a) { create(:issue, project: project) }
    let_it_be(:issue_b) { create(:issue, project: project) }

    let_it_be(:resource) do
      create(
        :merge_request,
        source_project: project,
        target_project: project,
        description: "Fixes #{issue_a.to_reference} Related #{issue_b.to_reference}"
      )
    end

    before_all do
      project.add_developer(user)
    end

    before do
      allow(resource.project).to receive(:default_branch)
        .and_return(resource.target_branch)
      resource.cache_merge_request_closes_issues!
    end

    describe '#closing_issues_links' do
      subject { described_class.new(resource, current_user: user).closing_issues_links }

      it 'presents closing issues links' do
        is_expected.to match("#{project.full_path}/-/issues/#{issue_a.iid}")
      end

      it 'does not present related issues links' do
        is_expected.not_to match("#{project.full_path}/-/issues/#{issue_b.iid}")
      end

      it 'appends status when closing issue is already closed' do
        issue_a.close
        is_expected.to match('(closed)')
      end
    end

    describe '#mentioned_issues_links' do
      subject do
        described_class.new(resource, current_user: user)
          .mentioned_issues_links
      end

      it 'presents related issues links' do
        is_expected.to match("#{project.full_path}/-/issues/#{issue_b.iid}")
      end

      it 'does not present closing issues links' do
        is_expected.not_to match("#{project.full_path}/-/issues/#{issue_a.iid}")
      end

      it 'appends status when mentioned issue is already closed' do
        issue_b.close
        is_expected.to match('(closed)')
      end
    end

    describe '#assign_to_closing_issues_path' do
      subject do
        described_class.new(resource, current_user: user)
          .assign_to_closing_issues_path
      end

      it { is_expected.to match("#{project.full_path}/-/merge_requests/#{resource.iid}/assign_related_issues") }
    end

    describe '#assign_to_closing_issues_count' do
      subject do
        described_class.new(resource, current_user: user)
          .assign_to_closing_issues_count
      end

      before do
        assign_issues_service = double(MergeRequests::AssignIssuesService, assignable_issues: assignable_issues)
        allow(MergeRequests::AssignIssuesService).to receive(:new)
          .and_return(assign_issues_service)
      end

      context 'single closing issue' do
        let(:issue) { create(:issue) }
        let(:assignable_issues) { [issue] }

        it 'returns correct count' do
          is_expected
            .to match(1)
        end
      end

      context 'multiple closing issues' do
        let(:issues) { build_list(:issue, 2) }
        let(:assignable_issues) { issues }

        it 'returns correct count' do
          is_expected
            .to match(2)
        end
      end

      context 'no closing issue' do
        let(:assignable_issues) { [] }

        it 'returns correct count' do
          is_expected
            .to match(0)
        end
      end
    end
  end

  describe '#cancel_auto_merge_path' do
    subject do
      described_class.new(resource, current_user: user)
        .cancel_auto_merge_path
    end

    context 'when can cancel mwps' do
      it 'returns path' do
        allow(resource).to receive(:can_cancel_auto_merge?)
          .with(user)
          .and_return(true)

        is_expected.to eq("/#{resource.project.full_path}/-/merge_requests/#{resource.iid}/cancel_auto_merge")
      end
    end

    context 'when cannot cancel mwps' do
      it 'returns nil' do
        allow(resource).to receive(:can_cancel_auto_merge?)
          .with(user)
          .and_return(false)

        is_expected.to be_nil
      end
    end
  end

  describe '#merge_path' do
    subject do
      described_class.new(resource, current_user: user).merge_path
    end

    context 'when can be merged by user' do
      it 'returns path' do
        allow(resource).to receive(:can_be_merged_by?)
          .with(user)
          .and_return(true)

        is_expected
          .to eq("/#{resource.project.full_path}/-/merge_requests/#{resource.iid}/merge")
      end
    end

    context 'when cannot be merged by user' do
      it 'returns nil' do
        allow(resource).to receive(:can_be_merged_by?)
          .with(user)
          .and_return(false)

        is_expected.to be_nil
      end
    end
  end

  describe '#create_issue_to_resolve_discussions_path' do
    subject do
      described_class.new(resource, current_user: user)
        .create_issue_to_resolve_discussions_path
    end

    context 'when can create issue and issues enabled' do
      it 'returns path' do
        allow(project).to receive(:issues_enabled?) { true }
        project.add_maintainer(user)

        is_expected
          .to eq("/#{resource.project.full_path}/-/issues/new?merge_request_to_resolve_discussions_of=#{resource.iid}")
      end
    end

    context 'when cannot create issue' do
      it 'returns nil' do
        allow(project).to receive(:issues_enabled?) { true }

        is_expected.to be_nil
      end
    end

    context 'when issues disabled' do
      it 'returns nil' do
        allow(project).to receive(:issues_enabled?) { false }
        project.add_maintainer(user)

        is_expected.to be_nil
      end
    end
  end

  describe '#remove_wip_path' do
    subject do
      described_class.new(resource, current_user: user).remove_wip_path
    end

    before do
      allow(resource).to receive(:draft?).and_return(true)
    end

    context 'when merge request enabled and has permission' do
      it 'has remove_wip_path' do
        allow(project).to receive(:merge_requests_enabled?) { true }
        project.add_maintainer(user)

        is_expected
          .to eq("/#{resource.project.full_path}/-/merge_requests/#{resource.iid}/remove_wip")
      end
    end

    context 'when has no permission' do
      it 'returns nil' do
        is_expected.to be_nil
      end
    end
  end

  describe '#target_branch_commits_path' do
    subject do
      described_class.new(resource, current_user: user)
        .target_branch_commits_path
    end

    context 'when target branch exists' do
      it 'returns path' do
        allow(resource).to receive(:target_branch_exists?) { true }

        is_expected
          .to eq("/#{resource.target_project.full_path}/-/commits/#{resource.target_branch}")
      end
    end

    context 'when target branch does not exist' do
      it 'returns nil' do
        allow(resource).to receive(:target_branch_exists?) { false }

        is_expected.to be_nil
      end
    end
  end

  describe '#source_branch_commits_path' do
    subject do
      described_class.new(resource, current_user: user)
        .source_branch_commits_path
    end

    context 'when source branch exists' do
      it 'returns path' do
        allow(resource).to receive(:source_branch_exists?) { true }

        is_expected
          .to eq("/#{resource.source_project.full_path}/-/commits/#{resource.source_branch}")
      end
    end

    context 'when source branch does not exist' do
      it 'returns nil' do
        allow(resource).to receive(:source_branch_exists?) { false }

        is_expected.to be_nil
      end
    end
  end

  describe '#target_branch_tree_path' do
    subject do
      described_class.new(resource, current_user: user)
        .target_branch_tree_path
    end

    context 'when target branch exists' do
      it 'returns path' do
        allow(resource).to receive(:target_branch_exists?) { true }

        is_expected
          .to eq("/#{resource.target_project.full_path}/-/tree/#{resource.target_branch}")
      end
    end

    context 'when target branch does not exist' do
      it 'returns nil' do
        allow(resource).to receive(:target_branch_exists?) { false }

        is_expected.to be_nil
      end
    end
  end

  describe '#source_branch_path' do
    subject do
      described_class.new(resource, current_user: user).source_branch_path
    end

    context 'when source branch exists' do
      it 'returns path' do
        allow(resource).to receive(:source_branch_exists?) { true }

        is_expected
          .to eq("/#{resource.source_project.full_path}/-/branches/#{resource.source_branch}")
      end
    end

    context 'when source branch does not exist' do
      it 'returns nil' do
        allow(resource).to receive(:source_branch_exists?) { false }

        is_expected.to be_nil
      end
    end
  end

  describe '#target_branch_path' do
    subject do
      described_class.new(resource, current_user: user).target_branch_path
    end

    context 'when target branch exists' do
      it 'returns path' do
        allow(resource).to receive(:target_branch_exists?) { true }

        is_expected
          .to eq("/#{resource.source_project.full_path}/-/branches/#{resource.target_branch}")
      end
    end

    context 'when target branch does not exist' do
      it 'returns nil' do
        allow(resource).to receive(:target_branch_exists?) { false }

        is_expected.to be_nil
      end
    end
  end

  describe '#source_branch_link' do
    subject { presenter.source_branch_link }

    let(:presenter) { described_class.new(resource, current_user: user) }

    context 'when source branch exists' do
      it 'returns link' do
        allow(resource).to receive(:source_branch_exists?) { true }

        is_expected
          .to eq("<a class=\"ref-name\" href=\"#{presenter.source_branch_commits_path}\">#{presenter.source_branch}</a>")
      end
    end

    context 'when source branch does not exist' do
      it 'returns text' do
        allow(resource).to receive(:source_branch_exists?) { false }

        is_expected.to eq("<span class=\"ref-name\">#{presenter.source_branch}</span>")
      end
    end
  end

  describe '#target_branch_link' do
    subject { presenter.target_branch_link }

    let(:presenter) { described_class.new(resource, current_user: user) }

    context 'when target branch exists' do
      it 'returns link' do
        allow(resource).to receive(:target_branch_exists?) { true }

        is_expected
          .to eq("<a class=\"ref-name\" href=\"#{presenter.target_branch_commits_path}\">#{presenter.target_branch}</a>")
      end
    end

    context 'when target branch does not exist' do
      it 'returns text' do
        allow(resource).to receive(:target_branch_exists?) { false }

        is_expected.to eq("<span class=\"ref-name\">#{presenter.target_branch}</span>")
      end
    end
  end

  describe '#source_branch_with_namespace_link' do
    subject do
      described_class.new(resource, current_user: user).source_branch_with_namespace_link
    end

    it 'returns link' do
      allow(resource).to receive(:source_branch_exists?) { true }

      is_expected
        .to eq("<a href=\"/#{resource.source_project.full_path}/-/tree/#{resource.source_branch}\">#{resource.source_branch}</a>")
    end

    it 'escapes html, when source_branch does not exist' do
      xss_attempt = "<img src='x' onerror=alert('bad stuff') />"

      allow(resource).to receive(:source_branch) { xss_attempt }
      allow(resource).to receive(:source_branch_exists?) { false }

      is_expected.to eq(ERB::Util.html_escape(xss_attempt))
    end
  end

  describe '#rebase_path' do
    before do
      allow(resource).to receive(:rebase_in_progress?) { rebase_in_progress }
      allow(resource).to receive(:should_be_rebased?) { should_be_rebased }

      allow_any_instance_of(Gitlab::UserAccess::RequestCacheExtension)
        .to receive(:can_push_to_branch?)
        .with(resource.source_branch)
        .and_return(can_push_to_branch)
    end

    subject do
      described_class.new(resource, current_user: user).rebase_path
    end

    context 'when can rebase' do
      let(:rebase_in_progress) { false }
      let(:can_push_to_branch) { true }
      let(:should_be_rebased) { true }

      before do
        allow(resource).to receive(:source_branch_exists?) { true }
      end

      it 'returns path' do
        is_expected
          .to eq("/#{project.full_path}/-/merge_requests/#{resource.iid}/rebase")
      end
    end

    context 'when cannot rebase' do
      context 'when rebase in progress' do
        let(:rebase_in_progress) { true }
        let(:can_push_to_branch) { true }
        let(:should_be_rebased) { true }

        it 'returns nil' do
          is_expected.to be_nil
        end
      end

      context 'when user cannot merge' do
        let(:rebase_in_progress) { false }
        let(:can_push_to_branch) { false }
        let(:should_be_rebased) { true }

        it 'returns nil' do
          is_expected.to be_nil
        end
      end

      context 'should not be rebased' do
        let(:rebase_in_progress) { false }
        let(:can_push_to_branch) { true }
        let(:should_be_rebased) { false }

        it 'returns nil' do
          is_expected.to be_nil
        end
      end
    end
  end

  describe '#can_push_to_source_branch' do
    before do
      allow(resource).to receive(:source_branch_exists?) { source_branch_exists }

      allow_any_instance_of(Gitlab::UserAccess::RequestCacheExtension)
        .to receive(:can_push_to_branch?)
              .with(resource.source_branch)
              .and_return(can_push_to_branch)
    end

    subject do
      described_class.new(resource, current_user: user).can_push_to_source_branch?
    end

    context 'when source branch exists AND user can push to source branch' do
      let(:source_branch_exists) { true }
      let(:can_push_to_branch) { true }

      it 'returns true' do
        is_expected.to eq(true)
      end
    end

    context 'when source branch does not exists' do
      let(:source_branch_exists) { false }
      let(:can_push_to_branch) { true }

      it 'returns false' do
        is_expected.to eq(false)
      end
    end

    context 'when user cannot push to source branch' do
      let(:source_branch_exists) { true }
      let(:can_push_to_branch) { false }

      it 'returns false' do
        is_expected.to eq(false)
      end
    end
  end

  describe '#api_approvals_path' do
    subject { described_class.new(resource, current_user: user).api_approvals_path }

    it { is_expected.to eq(expose_path("/api/v4/projects/#{project.id}/merge_requests/#{resource.iid}/approvals")) }
  end

  describe '#api_approve_path' do
    subject { described_class.new(resource, current_user: user).api_approve_path }

    it { is_expected.to eq(expose_path("/api/v4/projects/#{project.id}/merge_requests/#{resource.iid}/approve")) }
  end

  describe '#api_unapprove_path' do
    subject { described_class.new(resource, current_user: user).api_unapprove_path }

    it { is_expected.to eq(expose_path("/api/v4/projects/#{project.id}/merge_requests/#{resource.iid}/unapprove")) }
  end

  describe '#pipeline_coverage_delta' do
    subject { described_class.new(resource, current_user: user).pipeline_coverage_delta }

    context 'when merge request has pipeline coverage delta' do
      before do
        allow(resource).to receive(:pipeline_coverage_delta).and_return(35.0)
      end

      it 'formats coverage into 2 decimal points' do
        expect(subject).to eq('35.00')
      end
    end

    context 'when merge request does not have pipeline coverage delta' do
      before do
        allow(resource).to receive(:pipeline_coverage_delta).and_return(nil)
      end

      it 'returns nil' do
        expect(subject).to be_nil
      end
    end
  end
end