Read about our upcoming Code of Conduct on this issue

group_spec.rb 11.5 KB
Newer Older
1
2
require 'spec_helper'

Douwe Maan's avatar
Douwe Maan committed
3
describe Group, models: true do
4
  let!(:group) { create(:group, :access_requestable) }
5

6
  describe 'associations' do
7
    it { is_expected.to have_many :projects }
Rémy Coutable's avatar
Rémy Coutable committed
8
9
    it { is_expected.to have_many(:group_members).dependent(:destroy) }
    it { is_expected.to have_many(:users).through(:group_members) }
10
11
    it { is_expected.to have_many(:owners).through(:group_members) }
    it { is_expected.to have_many(:requesters).dependent(:destroy) }
Rémy Coutable's avatar
Rémy Coutable committed
12
13
14
    it { is_expected.to have_many(:project_group_links).dependent(:destroy) }
    it { is_expected.to have_many(:shared_projects).through(:project_group_links) }
    it { is_expected.to have_many(:notification_settings).dependent(:destroy) }
15
    it { is_expected.to have_many(:labels).class_name('GroupLabel') }
16
    it { is_expected.to have_many(:uploads).dependent(:destroy) }
17
    it { is_expected.to have_one(:chat_team) }
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

    describe '#members & #requesters' do
      let(:requester) { create(:user) }
      let(:developer) { create(:user) }
      before do
        group.request_access(requester)
        group.add_developer(developer)
      end

      describe '#members' do
        it 'includes members and exclude requesters' do
          member_user_ids = group.members.pluck(:user_id)

          expect(member_user_ids).to include(developer.id)
          expect(member_user_ids).not_to include(requester.id)
        end
      end

      describe '#requesters' do
        it 'does not include requesters' do
          requester_user_ids = group.requesters.pluck(:user_id)

          expect(requester_user_ids).to include(requester.id)
          expect(requester_user_ids).not_to include(developer.id)
        end
      end
    end
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
45
46
  end

47
48
49
50
51
52
53
54
  describe 'modules' do
    subject { described_class }

    it { is_expected.to include_module(Referable) }
  end

  describe 'validations' do
    it { is_expected.to validate_presence_of :name }
55
    it { is_expected.to validate_uniqueness_of(:name).scoped_to(:parent_id) }
56
57
    it { is_expected.to validate_presence_of :path }
    it { is_expected.not_to validate_presence_of :owner }
58
59
    it { is_expected.to validate_presence_of :two_factor_grace_period }
    it { is_expected.to validate_numericality_of(:two_factor_grace_period).is_greater_than_or_equal_to(0) }
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

    describe 'path validation' do
      it 'rejects paths reserved on the root namespace when the group has no parent' do
        group = build(:group, path: 'api')

        expect(group).not_to be_valid
      end

      it 'allows root paths when the group has a parent' do
        group = build(:group, path: 'api', parent: create(:group))

        expect(group).to be_valid
      end

      it 'rejects any wildcard paths when not a top level group' do
        group = build(:group, path: 'tree', parent: create(:group))

        expect(group).not_to be_valid
      end
    end
80
81
  end

82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
  describe '.visible_to_user' do
    let!(:group) { create(:group) }
    let!(:user)  { create(:user) }

    subject { described_class.visible_to_user(user) }

    describe 'when the user has access to a group' do
      before do
        group.add_user(user, Gitlab::Access::MASTER)
      end

      it { is_expected.to eq([group]) }
    end

    describe 'when the user does not have access to any groups' do
      it { is_expected.to eq([]) }
    end
  end

Felipe Artur's avatar
Felipe Artur committed
101
  describe 'scopes' do
102
103
    let!(:private_group)  { create(:group, :private)  }
    let!(:internal_group) { create(:group, :internal) }
Felipe Artur's avatar
Felipe Artur committed
104
105

    describe 'public_only' do
106
      subject { described_class.public_only.to_a }
Felipe Artur's avatar
Felipe Artur committed
107

108
      it { is_expected.to eq([group]) }
Felipe Artur's avatar
Felipe Artur committed
109
110
111
    end

    describe 'public_and_internal_only' do
Douwe Maan's avatar
Douwe Maan committed
112
      subject { described_class.public_and_internal_only.to_a }
Felipe Artur's avatar
Felipe Artur committed
113

114
115
116
117
118
119
120
      it { is_expected.to match_array([group, internal_group]) }
    end

    describe 'non_public_only' do
      subject { described_class.non_public_only.to_a }

      it { is_expected.to match_array([private_group, internal_group]) }
Felipe Artur's avatar
Felipe Artur committed
121
122
123
    end
  end

124
125
126
127
128
  describe '#to_reference' do
    it 'returns a String reference to the object' do
      expect(group.to_reference).to eq "@#{group.name}"
    end
  end
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
129

130
  describe '#users' do
131
    it { expect(group.users).to eq(group.owners) }
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
132
133
  end

134
  describe '#human_name' do
135
    it { expect(group.human_name).to eq(group.name) }
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
136
  end
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
137

138
  describe '#add_user' do
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
139
    let(:user) { create(:user) }
140
    before { group.add_user(user, GroupMember::MASTER) }
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
141

142
    it { expect(group.group_members.masters.map(&:user)).to include(user) }
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
143
  end
144

145
  describe '#add_users' do
146
    let(:user) { create(:user) }
147
    before { group.add_users([user.id], GroupMember::GUEST) }
148

149
    it "updates the group permission" do
150
      expect(group.group_members.guests.map(&:user)).to include(user)
151
      group.add_users([user.id], GroupMember::DEVELOPER)
152
153
      expect(group.group_members.developers.map(&:user)).to include(user)
      expect(group.group_members.guests.map(&:user)).not_to include(user)
154
155
    end
  end
Steven Thonus's avatar
Steven Thonus committed
156

157
  describe '#avatar_type' do
Steven Thonus's avatar
Steven Thonus committed
158
    let(:user) { create(:user) }
159
    before { group.add_user(user, GroupMember::MASTER) }
Steven Thonus's avatar
Steven Thonus committed
160

161
    it "is true if avatar is image" do
Steven Thonus's avatar
Steven Thonus committed
162
      group.update_attribute(:avatar, 'uploads/avatar.png')
163
      expect(group.avatar_type).to be_truthy
Steven Thonus's avatar
Steven Thonus committed
164
165
    end

166
    it "is false if avatar is html page" do
Steven Thonus's avatar
Steven Thonus committed
167
      group.update_attribute(:avatar, 'uploads/avatar.html')
168
      expect(group.avatar_type).to eq(["only images allowed"])
Steven Thonus's avatar
Steven Thonus committed
169
170
    end
  end
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196

  describe '.search' do
    it 'returns groups with a matching name' do
      expect(described_class.search(group.name)).to eq([group])
    end

    it 'returns groups with a partially matching name' do
      expect(described_class.search(group.name[0..2])).to eq([group])
    end

    it 'returns groups with a matching name regardless of the casing' do
      expect(described_class.search(group.name.upcase)).to eq([group])
    end

    it 'returns groups with a matching path' do
      expect(described_class.search(group.path)).to eq([group])
    end

    it 'returns groups with a partially matching path' do
      expect(described_class.search(group.path[0..2])).to eq([group])
    end

    it 'returns groups with a matching path regardless of the casing' do
      expect(described_class.search(group.path.upcase)).to eq([group])
    end
  end
Rémy Coutable's avatar
Rémy Coutable committed
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219

  describe '#has_owner?' do
    before { @members = setup_group_members(group) }

    it { expect(group.has_owner?(@members[:owner])).to be_truthy }
    it { expect(group.has_owner?(@members[:master])).to be_falsey }
    it { expect(group.has_owner?(@members[:developer])).to be_falsey }
    it { expect(group.has_owner?(@members[:reporter])).to be_falsey }
    it { expect(group.has_owner?(@members[:guest])).to be_falsey }
    it { expect(group.has_owner?(@members[:requester])).to be_falsey }
  end

  describe '#has_master?' do
    before { @members = setup_group_members(group) }

    it { expect(group.has_master?(@members[:owner])).to be_falsey }
    it { expect(group.has_master?(@members[:master])).to be_truthy }
    it { expect(group.has_master?(@members[:developer])).to be_falsey }
    it { expect(group.has_master?(@members[:reporter])).to be_falsey }
    it { expect(group.has_master?(@members[:guest])).to be_falsey }
    it { expect(group.has_master?(@members[:requester])).to be_falsey }
  end

220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
  describe '#lfs_enabled?' do
    context 'LFS enabled globally' do
      before do
        allow(Gitlab.config.lfs).to receive(:enabled).and_return(true)
      end

      it 'returns true when nothing is set' do
        expect(group.lfs_enabled?).to be_truthy
      end

      it 'returns false when set to false' do
        group.update_attribute(:lfs_enabled, false)

        expect(group.lfs_enabled?).to be_falsey
      end

      it 'returns true when set to true' do
        group.update_attribute(:lfs_enabled, true)

        expect(group.lfs_enabled?).to be_truthy
      end
    end

    context 'LFS disabled globally' do
      before do
        allow(Gitlab.config.lfs).to receive(:enabled).and_return(false)
      end

      it 'returns false when nothing is set' do
        expect(group.lfs_enabled?).to be_falsey
      end

      it 'returns false when set to false' do
        group.update_attribute(:lfs_enabled, false)

        expect(group.lfs_enabled?).to be_falsey
      end

      it 'returns false when set to true' do
        group.update_attribute(:lfs_enabled, true)

        expect(group.lfs_enabled?).to be_falsey
      end
    end
  end

266
267
268
269
270
271
272
273
274
275
276
277
  describe '#owners' do
    let(:owner) { create(:user) }
    let(:developer) { create(:user) }

    it 'returns the owners of a Group' do
      group.add_owner(owner)
      group.add_developer(developer)

      expect(group.owners).to eq([owner])
    end
  end

Rémy Coutable's avatar
Rémy Coutable committed
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
  def setup_group_members(group)
    members = {
      owner: create(:user),
      master: create(:user),
      developer: create(:user),
      reporter: create(:user),
      guest: create(:user),
      requester: create(:user)
    }

    group.add_user(members[:owner], GroupMember::OWNER)
    group.add_user(members[:master], GroupMember::MASTER)
    group.add_user(members[:developer], GroupMember::DEVELOPER)
    group.add_user(members[:reporter], GroupMember::REPORTER)
    group.add_user(members[:guest], GroupMember::GUEST)
    group.request_access(members[:requester])

    members
  end
297
298
299
300
301

  describe '#web_url' do
    it 'returns the canonical URL' do
      expect(group.web_url).to include("groups/#{group.name}")
    end
302
303
304
305
306
307

    context 'nested group' do
      let(:nested_group) { create(:group, :nested) }

      it { expect(nested_group.web_url).to include("groups/#{nested_group.full_path}") }
    end
308
  end
309
310

  describe 'nested group' do
311
    subject { build(:group, :nested) }
312
313
314
315

    it { is_expected.to be_valid }
    it { expect(subject.parent).to be_kind_of(Group) }
  end
316
317
318
319
320
321
322
323
324
325
326

  describe '#members_with_parents' do
    let!(:group) { create(:group, :nested) }
    let!(:master) { group.parent.add_user(create(:user), GroupMember::MASTER) }
    let!(:developer) { group.add_user(create(:user), GroupMember::DEVELOPER) }

    it 'returns parents members' do
      expect(group.members_with_parents).to include(developer)
      expect(group.members_with_parents).to include(master)
    end
  end
327
328
329
330
331
332
333
334
335
336
337
338
339

  describe '#user_ids_for_project_authorizations' do
    it 'returns the user IDs for which to refresh authorizations' do
      master = create(:user)
      developer = create(:user)

      group.add_user(master, GroupMember::MASTER)
      group.add_user(developer, GroupMember::DEVELOPER)

      expect(group.user_ids_for_project_authorizations).
        to include(master.id, developer.id)
    end
  end
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379

  describe '#update_two_factor_requirement' do
    let(:user) { create(:user) }

    before do
      group.add_user(user, GroupMember::OWNER)
    end

    it 'is called when require_two_factor_authentication is changed' do
      expect_any_instance_of(User).to receive(:update_two_factor_requirement)

      group.update!(require_two_factor_authentication: true)
    end

    it 'is called when two_factor_grace_period is changed' do
      expect_any_instance_of(User).to receive(:update_two_factor_requirement)

      group.update!(two_factor_grace_period: 23)
    end

    it 'is not called when other attributes are changed' do
      expect_any_instance_of(User).not_to receive(:update_two_factor_requirement)

      group.update!(description: 'foobar')
    end

    it 'calls #update_two_factor_requirement on each group member' do
      other_user = create(:user)
      group.add_user(other_user, GroupMember::OWNER)

      calls = 0
      allow_any_instance_of(User).to receive(:update_two_factor_requirement) do
        calls += 1
      end

      group.update!(require_two_factor_authentication: true, two_factor_grace_period: 23)

      expect(calls).to eq 2
    end
  end
380
end