summaryrefslogtreecommitdiff
path: root/spec/serializers/merge_request_entity_spec.rb
blob: 039ec5d29dae772408614bd8ddb421c3ff14bae2 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
require 'spec_helper'

describe MergeRequestEntity do
  let(:project)  { create :empty_project }
  let(:resource) { create(:merge_request, source_project: project, target_project: project) }
  let(:user)     { create(:user) }

  let(:request) { double('request', current_user: user) }

  subject do
    described_class.new(resource, request: request).as_json
  end

  it 'includes author' do
    req = double('request')

    author_payload = UserEntity
      .represent(resource.author, request: req)
      .as_json

    expect(subject[:author]).to eq(author_payload)
  end

  it 'includes pipeline' do
    req = double('request', current_user: user)
    pipeline = build_stubbed(:ci_pipeline)
    allow(resource).to receive(:head_pipeline).and_return(pipeline)

    pipeline_payload = PipelineEntity
      .represent(pipeline, request: req)
      .as_json

    expect(subject[:pipeline]).to eq(pipeline_payload)
  end

  it 'includes issues_links' do
    issues_links = subject[:issues_links]

    expect(issues_links).to include(:closing, :mentioned_but_not_closing,
                                    :assign_to_closing)
  end

  it 'has important MergeRequest attributes' do
    expect(subject).to include(:diff_head_sha, :merge_commit_message,
                               :has_conflicts, :has_ci, :merge_path,
                               :conflict_resolution_path,
                               :cancel_merge_when_pipeline_succeeds_path,
                               :create_issue_to_resolve_discussions_path,
                               :source_branch_path, :target_branch_path)
  end

  it 'has email_patches_path' do
    expect(subject[:email_patches_path])
      .to eq("/#{resource.project.full_path}/merge_requests/#{resource.iid}.patch")
  end

  it 'has plain_diff_path' do
    expect(subject[:plain_diff_path])
      .to eq("/#{resource.project.full_path}/merge_requests/#{resource.iid}.diff")
  end

  it 'has merge_commit_message_with_description' do
    expect(subject[:merge_commit_message_with_description])
      .to eq(resource.merge_commit_message(include_description: true))
  end

  describe 'diff_head_commit_short_id' do
    context 'when no diff head commit' do
      let(:project) { create :empty_project }

      it 'returns nil' do
        expect(subject[:diff_head_commit_short_id]).to be_nil
      end
    end

    context 'when diff head commit present' do
      let(:project) { create :project }

      it 'returns diff head commit short id' do
        expect(subject[:diff_head_commit_short_id]).to eq(resource.diff_head_commit.short_id)
      end
    end
  end

  it 'includes merge_event' do
    create(:event, :merged, author: user, project: resource.project, target: resource)

    expect(subject[:merge_event]).to include(:author, :updated_at)
  end

  it 'includes closed_event' do
    create(:event, :closed, author: user, project: resource.project, target: resource)

    expect(subject[:closed_event]).to include(:author, :updated_at)
  end

  describe 'diverged_commits_count' do
    context 'when MR open and its diverging' do
      it 'returns diverged commits count' do
        allow(resource).to receive_messages(open?: true, diverged_from_target_branch?: true,
                                            diverged_commits_count: 10)

        expect(subject[:diverged_commits_count]).to eq(10)
      end
    end

    context 'when MR is not open' do
      it 'returns 0' do
        allow(resource).to receive_messages(open?: false)

        expect(subject[:diverged_commits_count]).to be_zero
      end
    end

    context 'when MR is not diverging' do
      it 'returns 0' do
        allow(resource).to receive_messages(open?: true, diverged_from_target_branch?: false)

        expect(subject[:diverged_commits_count]).to be_zero
      end
    end
  end
end