debian-mirror-gitlab/spec/helpers/commits_helper_spec.rb

# frozen_string_literal: true

require 'spec_helper'

RSpec.describe CommitsHelper do
  include ProjectForksHelper

  describe 'commit_author_link' do
    it 'escapes the author email' do
      commit = double(
        author: nil,
        author_name: 'Persistent XSS',
        author_email: 'my@email.com" onmouseover="alert(1)'
      )

      expect(helper.commit_author_link(commit))
        .not_to include('onmouseover="alert(1)"')
    end

    it 'escapes the author name' do
      user = build_stubbed(:user, name: 'Foo <script>alert("XSS")</script>')

      commit = double(author: user, author_name: '', author_email: '')

      expect(helper.commit_author_link(commit))
        .to include('Foo &lt;script&gt;')
      expect(helper.commit_author_link(commit, avatar: true))
        .to include('commit-author-name', 'js-user-link', 'Foo &lt;script&gt;')
    end
  end

  describe 'commit_committer_link' do
    it 'escapes the committer email' do
      commit = double(
        committer: nil,
        committer_name: 'Persistent XSS',
        committer_email: 'my@email.com" onmouseover="alert(1)'
      )

      expect(helper.commit_committer_link(commit))
        .not_to include('onmouseover="alert(1)"')
    end

    it 'escapes the committer name' do
      user = build_stubbed(:user, name: 'Foo <script>alert("XSS")</script>')

      commit = double(committer: user, committer_name: '', committer_email: '')

      expect(helper.commit_committer_link(commit))
        .to include('Foo &lt;script&gt;')
      expect(helper.commit_committer_link(commit, avatar: true))
        .to include('commit-committer-name', 'Foo &lt;script&gt;')
    end
  end

  describe '#view_file_button' do
    let(:project) { build(:project) }
    let(:path) { 'path/to/file' }
    let(:sha) { '1234567890' }

    subject do
      helper.view_file_button(sha, path, project)
    end

    it 'links to project files' do
      expect(subject).to have_link('1234567', href: helper.project_blob_path(project, "#{sha}/#{path}"))
    end
  end

  describe '#view_on_environment_button' do
    let(:project) { create(:project) }
    let(:environment) { create(:environment, external_url: 'http://example.com') }
    let(:path) { 'source/file.html' }
    let(:sha) { RepoHelpers.sample_commit.id }

    before do
      allow(environment).to receive(:external_url_for).with(path, sha).and_return('http://example.com/file.html')
    end

    it 'returns a link tag linking to the file in the environment' do
      html = helper.view_on_environment_button(sha, path, environment)
      node = Nokogiri::HTML.parse(html).at_css('a')

      expect(node[:title]).to eq('View on example.com')
      expect(node[:href]).to eq('http://example.com/file.html')
    end
  end

  describe '#commit_to_html' do
    let(:project) { create(:project, :repository) }
    let(:ref) { 'master' }
    let(:commit) { project.commit(ref) }

    it 'renders HTML representation of a commit' do
      assign(:project, project)
      allow(helper).to receive(:current_user).and_return(project.owner)

      expect(helper.commit_to_html(commit, ref, project)).to include('<div class="commit-content')
    end
  end

  describe 'commit_path' do
    it 'returns a persisted merge request commit path' do
      project = create(:project, :repository)
      persisted_merge_request = create(:merge_request, source_project: project, target_project: project)
      commit = project.repository.commit

      expect(helper.commit_path(persisted_merge_request.project, commit, merge_request: persisted_merge_request))
        .to eq(diffs_project_merge_request_path(project, persisted_merge_request, commit_id: commit.id))
    end

    it 'returns a non-persisted merge request commit path which commits still reside in the source project' do
      source_project = create(:project, :repository)
      target_project = create(:project, :repository)
      non_persisted_merge_request = build(:merge_request, source_project: source_project, target_project: target_project)
      commit = source_project.repository.commit

      expect(helper.commit_path(non_persisted_merge_request.project, commit, merge_request: non_persisted_merge_request))
        .to eq(project_commit_path(source_project, commit))
    end

    it 'returns a project commit path' do
      project = create(:project, :repository)
      commit = project.repository.commit

      expect(helper.commit_path(project, commit)).to eq(project_commit_path(project, commit))
    end
  end

  describe "#conditionally_paginate_diff_files" do
    let(:diffs_collection) { instance_double(Gitlab::Diff::FileCollection::Commit, diff_files: diff_files) }
    let(:diff_files) { Gitlab::Git::DiffCollection.new(files) }
    let(:page) { nil }

    let(:files) do
      Array.new(85).map do
        { too_large: false, diff: "" }
      end
    end

    let(:params) do
      {
        page: page
      }
    end

    subject { helper.conditionally_paginate_diff_files(diffs_collection, paginate: paginate, per: Projects::CommitController::COMMIT_DIFFS_PER_PAGE) }

    before do
      allow(helper).to receive(:params).and_return(params)
    end

    context "pagination is enabled" do
      let(:paginate) { true }

      it "has been paginated" do
        expect(subject).to be_an(Array)
      end

      it "can change the number of items per page" do
        commits = helper.conditionally_paginate_diff_files(diffs_collection, paginate: paginate, per: 10)

        expect(commits).to be_an(Array)
        expect(commits.size).to eq(10)
      end

      context "page 1" do
        let(:page) { 1 }

        it "has 20 diffs" do
          expect(subject.size).to eq(20)
        end
      end

      context "page 5" do
        let(:page) { 5 }

        it "has the remaining 5 out of 85 diffs" do
          expect(subject.size).to eq(5)
        end
      end
    end

    context "pagination is disabled" do
      let(:paginate) { false }

      it "returns a standard DiffCollection" do
        expect(subject).to be_a(Gitlab::Git::DiffCollection)
      end
    end
  end

  describe '#cherry_pick_projects_data' do
    let(:project) { create(:project, :repository) }
    let(:user) { create(:user, maintainer_projects: [project]) }
    let!(:forked_project) { fork_project(project, user, { namespace: user.namespace, repository: true }) }

    before do
      allow(helper).to receive(:current_user).and_return(user)
    end

    it 'returns data for cherry picking into a project' do
      expect(helper.cherry_pick_projects_data(forked_project)).to match_array([
        { id: project.id.to_s, name: project.full_path, refsUrl: refs_project_path(project) },
        { id: forked_project.id.to_s, name: forked_project.full_path, refsUrl: refs_project_path(forked_project) }
      ])
    end
  end

  describe "#commit_options_dropdown_data" do
    let(:project) { build(:project, :repository) }
    let(:commit) { build(:commit) }
    let(:user) { build(:user) }

    subject { helper.commit_options_dropdown_data(project, commit) }

    context "when user is logged in" do
      before do
        allow(helper).to receive(:can?).with(user, :push_code, project).and_return(true)
        allow(helper).to receive(:current_user).and_return(user)
      end

      it "returns data as expected" do
        is_expected.to eq standard_expected_data
      end

      context "when can not collaborate on project" do
        before do
          allow(helper).to receive(:can_collaborate_with_project?).with(project).and_return(false)
        end

        it "returns data as expected" do
          no_collaboration_values = {
            can_revert: 'false',
            can_cherry_pick: 'false'
          }

          is_expected.to eq standard_expected_data.merge(no_collaboration_values)
        end
      end

      context "when commit has already been reverted" do
        before do
          allow(commit).to receive(:has_been_reverted?).with(user).and_return(true)
        end

        it "returns data as expected" do
          is_expected.to eq standard_expected_data.merge({ can_revert: 'false' })
        end
      end
    end

    context "when user is not logged in" do
      before do
        allow(helper).to receive(:can?).with(nil, :push_code, project).and_return(false)
        allow(helper).to receive(:current_user).and_return(nil)
      end

      it "returns data as expected" do
        logged_out_values = {
          can_revert: '',
          can_cherry_pick: '',
          can_tag: 'false'
        }

        is_expected.to eq standard_expected_data.merge(logged_out_values)
      end
    end

    def standard_expected_data
      {
        new_project_tag_path: new_project_tag_path(project, ref: commit),
        email_patches_path: project_commit_path(project, commit, format: :patch),
        plain_diff_path: project_commit_path(project, commit, format: :diff),
        can_revert: 'true',
        can_cherry_pick: 'true',
        can_tag: 'true',
        can_email_patches: 'true'
      }
    end
  end

  describe "#commit_partial_cache_key" do
    subject(:cache_key) { helper.commit_partial_cache_key(commit, ref: ref, merge_request: merge_request, request: request) }

    let(:commit) { create(:commit).present(current_user: user) }
    let(:commit_status) { Gitlab::Ci::Status::Running.new(pipeline, user) }
    let(:pipeline) { create(:ci_pipeline, :running) }
    let(:user) { create(:user) }
    let(:ref) { "master" }
    let(:merge_request) { create(:merge_request) }
    let(:request) { double(xhr?: true) }
    let(:current_path) { "test" }

    before do
      expect(commit).to receive(:status_for).with(ref).and_return(commit_status)
      assign(:path, current_path)
    end

    it { is_expected.to be_an(Array) }
    it { is_expected.to include(commit) }
    it { is_expected.to include(commit.author) }
    it { is_expected.to include(ref) }

    it do
      is_expected.to include(
        {
          merge_request: merge_request.cache_key,
          pipeline_status: pipeline.cache_key,
          xhr: true,
          controller: "commits",
          path: current_path
        }
      )
    end

    describe "final cache key output" do
      subject { ActiveSupport::Cache.expand_cache_key(cache_key) }

      it { is_expected.to include(commit.cache_key) }
      it { is_expected.to include(pipeline.cache_key) }
    end
  end
end