group_spec.rb 10.9 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 }
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) }
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
  end

62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80
  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

81
  describe 'scopes' do
82 83
    let!(:private_group)  { create(:group, :private)  }
    let!(:internal_group) { create(:group, :internal) }
84 85

    describe 'public_only' do
86
      subject { described_class.public_only.to_a }
87

88
      it { is_expected.to eq([group]) }
89 90 91
    end

    describe 'public_and_internal_only' do
Douwe Maan's avatar
Douwe Maan committed
92
      subject { described_class.public_and_internal_only.to_a }
93

94 95 96 97 98 99 100
      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]) }
101 102 103
    end
  end

104 105 106 107 108
  describe '#to_reference' do
    it 'returns a String reference to the object' do
      expect(group.to_reference).to eq "@#{group.name}"
    end
  end
109

110
  describe '#users' do
111
    it { expect(group.users).to eq(group.owners) }
112 113
  end

114
  describe '#human_name' do
115
    it { expect(group.human_name).to eq(group.name) }
116
  end
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
117

118
  describe '#add_user' do
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
119
    let(:user) { create(:user) }
120
    before { group.add_user(user, GroupMember::MASTER) }
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
121

122
    it { expect(group.group_members.masters.map(&:user)).to include(user) }
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
123
  end
124

125
  describe '#add_users' do
126
    let(:user) { create(:user) }
127
    before { group.add_users([user.id], GroupMember::GUEST) }
128

129
    it "updates the group permission" do
130
      expect(group.group_members.guests.map(&:user)).to include(user)
131
      group.add_users([user.id], GroupMember::DEVELOPER)
132 133
      expect(group.group_members.developers.map(&:user)).to include(user)
      expect(group.group_members.guests.map(&:user)).not_to include(user)
134 135
    end
  end
Steven Thonus's avatar
Steven Thonus committed
136

137
  describe '#avatar_type' do
Steven Thonus's avatar
Steven Thonus committed
138
    let(:user) { create(:user) }
139
    before { group.add_user(user, GroupMember::MASTER) }
Steven Thonus's avatar
Steven Thonus committed
140

141
    it "is true if avatar is image" do
Steven Thonus's avatar
Steven Thonus committed
142
      group.update_attribute(:avatar, 'uploads/avatar.png')
143
      expect(group.avatar_type).to be_truthy
Steven Thonus's avatar
Steven Thonus committed
144 145
    end

146
    it "is false if avatar is html page" do
Steven Thonus's avatar
Steven Thonus committed
147
      group.update_attribute(:avatar, 'uploads/avatar.html')
148
      expect(group.avatar_type).to eq(["only images allowed"])
Steven Thonus's avatar
Steven Thonus committed
149 150
    end
  end
151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176

  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
177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199

  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

200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 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
  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

246 247 248 249 250 251 252 253 254 255 256 257
  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

258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276
  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
277 278 279 280 281

  describe '#web_url' do
    it 'returns the canonical URL' do
      expect(group.web_url).to include("groups/#{group.name}")
    end
282 283 284 285 286 287

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

      it { expect(nested_group.web_url).to include("groups/#{nested_group.full_path}") }
    end
288
  end
289 290

  describe 'nested group' do
291
    subject { build(:group, :nested) }
292 293 294 295

    it { is_expected.to be_valid }
    it { expect(subject.parent).to be_kind_of(Group) }
  end
296 297 298 299 300 301 302 303 304 305 306

  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
307 308 309 310 311 312 313 314 315 316 317 318 319

  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
320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359

  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
360
end