summaryrefslogtreecommitdiff
path: root/spec/requests/api/graphql/group/merge_requests_spec.rb
blob: adaee3031a95c0c82b6e2d7f7a556be0c9d844cc (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
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
# frozen_string_literal: true

require 'spec_helper'

# Based on ee/spec/requests/api/epics_spec.rb
# Should follow closely in order to ensure all situations are covered
RSpec.describe 'Query.group.mergeRequests', feature_category: :code_review_workflow do
  include GraphqlHelpers

  let_it_be(:group)     { create(:group) }
  let_it_be(:sub_group) { create(:group, parent: group) }

  let_it_be(:project_a) { create(:project, :repository, group: group) }
  let_it_be(:project_b) { create(:project, :repository, group: group) }
  let_it_be(:project_c) { create(:project, :repository, group: sub_group) }
  let_it_be(:project_x) { create(:project, :repository) }
  let_it_be(:user)      { create(:user, developer_projects: [project_x]) }

  let_it_be(:archived_project) { create(:project, :archived, :repository, group: group) }
  let_it_be(:archived_mr) { create(:merge_request, source_project: archived_project) }

  let_it_be(:mr_attrs) do
    { target_branch: 'master' }
  end

  let_it_be(:mr_traits) do
    [:unique_branches, :unique_author]
  end

  let_it_be(:mrs_a, reload: true) { create_list(:merge_request, 2, *mr_traits, **mr_attrs, source_project: project_a) }
  let_it_be(:mrs_b, reload: true) { create_list(:merge_request, 2, *mr_traits, **mr_attrs, source_project: project_b) }
  let_it_be(:mrs_c, reload: true) { create_list(:merge_request, 2, *mr_traits, **mr_attrs, source_project: project_c) }
  let_it_be(:other_mr) { create(:merge_request, source_project: project_x) }

  let(:mrs_data) { graphql_data_at(:group, :merge_requests, :nodes) }

  before do
    group.add_developer(user)
  end

  def expected_mrs(mrs)
    mrs.map { |mr| a_graphql_entity_for(mr) }
  end

  describe 'not passing any arguments' do
    let(:query) do
      <<~GQL
      query($path: ID!) {
        group(fullPath: $path) {
          mergeRequests { nodes { id } }
        }
      }
      GQL
    end

    it 'can find all merge requests in the group, excluding sub-groups' do
      post_graphql(query, current_user: user, variables: { path: group.full_path })

      expect(mrs_data).to match_array(expected_mrs(mrs_a + mrs_b))
    end
  end

  describe 'restricting by author' do
    let(:query) do
      <<~GQL
      query($path: ID!, $user: String) {
        group(fullPath: $path) {
          mergeRequests(authorUsername: $user) { nodes { id author { username } } }
        }
      }
      GQL
    end

    let(:author) { mrs_b.first.author }

    it 'can find all merge requests with user as author' do
      post_graphql(query, current_user: user, variables: { user: author.username, path: group.full_path })

      expect(mrs_data).to match_array(expected_mrs([mrs_b.first]))
    end
  end

  describe 'restricting by assignee' do
    let(:query) do
      <<~GQL
      query($path: ID!, $user: String) {
        group(fullPath: $path) {
          mergeRequests(assigneeUsername: $user) { nodes { id } }
        }
      }
      GQL
    end

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

    before_all do
      mrs_b.second.assignees << assignee
      mrs_a.first.assignees << assignee
    end

    it 'can find all merge requests assigned to user' do
      post_graphql(query, current_user: user, variables: { user: assignee.username, path: group.full_path })

      expect(mrs_data).to match_array(expected_mrs([mrs_a.first, mrs_b.second]))
    end
  end

  describe 'passing include_subgroups: true' do
    let(:query) do
      <<~GQL
      query($path: ID!) {
        group(fullPath: $path) {
          mergeRequests(includeSubgroups: true) { nodes { id } }
        }
      }
      GQL
    end

    it 'can find all merge requests in the group, including sub-groups' do
      post_graphql(query, current_user: user, variables: { path: group.full_path })

      expect(mrs_data).to match_array(expected_mrs(mrs_a + mrs_b + mrs_c))
    end
  end

  describe 'passing include_archived: true' do
    let(:query) do
      <<~GQL
      query($path: ID!) {
        group(fullPath: $path) {
          mergeRequests(includeArchived: true) { nodes { id } }
        }
      }
      GQL
    end

    it 'can find all merge requests in the group, including from archived projects' do
      post_graphql(query, current_user: user, variables: { path: group.full_path })

      expect(mrs_data).to match_array(expected_mrs(mrs_a + mrs_b + [archived_mr]))
    end
  end
end