group_spec.rb 8.37 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 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

    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
43 44
  end

45 46 47 48 49 50 51 52 53 54 55 56 57 58
  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 }
    it { is_expected.to validate_uniqueness_of(:name) }
    it { is_expected.to validate_presence_of :path }
    it { is_expected.to validate_uniqueness_of(:path) }
    it { is_expected.not_to validate_presence_of :owner }
  end

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

78
  describe 'scopes' do
79 80
    let!(:private_group)  { create(:group, :private)  }
    let!(:internal_group) { create(:group, :internal) }
81 82

    describe 'public_only' do
83
      subject { described_class.public_only.to_a }
84

Douwe Maan's avatar
Douwe Maan committed
85
      it{ is_expected.to eq([group]) }
86 87 88
    end

    describe 'public_and_internal_only' do
Douwe Maan's avatar
Douwe Maan committed
89
      subject { described_class.public_and_internal_only.to_a }
90

Douwe Maan's avatar
Douwe Maan committed
91
      it{ is_expected.to match_array([group, internal_group]) }
92 93 94
    end
  end

95 96 97 98 99
  describe '#to_reference' do
    it 'returns a String reference to the object' do
      expect(group.to_reference).to eq "@#{group.name}"
    end
  end
100

101
  describe '#users' do
102
    it { expect(group.users).to eq(group.owners) }
103 104
  end

105
  describe '#human_name' do
106
    it { expect(group.human_name).to eq(group.name) }
107
  end
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
108

109
  describe '#add_user' do
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
110
    let(:user) { create(:user) }
111
    before { group.add_user(user, GroupMember::MASTER) }
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
112

113
    it { expect(group.group_members.masters.map(&:user)).to include(user) }
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
114
  end
115

116
  describe '#add_users' do
117
    let(:user) { create(:user) }
118
    before { group.add_users([user.id], GroupMember::GUEST) }
119

120
    it "updates the group permission" do
121
      expect(group.group_members.guests.map(&:user)).to include(user)
122
      group.add_users([user.id], GroupMember::DEVELOPER)
123 124
      expect(group.group_members.developers.map(&:user)).to include(user)
      expect(group.group_members.guests.map(&:user)).not_to include(user)
125 126
    end
  end
Steven Thonus's avatar
Steven Thonus committed
127

128
  describe '#avatar_type' do
Steven Thonus's avatar
Steven Thonus committed
129
    let(:user) { create(:user) }
130
    before { group.add_user(user, GroupMember::MASTER) }
Steven Thonus's avatar
Steven Thonus committed
131

132
    it "is true if avatar is image" do
Steven Thonus's avatar
Steven Thonus committed
133
      group.update_attribute(:avatar, 'uploads/avatar.png')
134
      expect(group.avatar_type).to be_truthy
Steven Thonus's avatar
Steven Thonus committed
135 136
    end

137
    it "is false if avatar is html page" do
Steven Thonus's avatar
Steven Thonus committed
138
      group.update_attribute(:avatar, 'uploads/avatar.html')
139
      expect(group.avatar_type).to eq(["only images allowed"])
Steven Thonus's avatar
Steven Thonus committed
140 141
    end
  end
142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167

  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
168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190

  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

191 192 193 194 195 196 197 198 199 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
  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

237 238 239 240 241 242 243 244 245 246 247 248
  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

249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267
  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
268 269 270 271 272 273

  describe '#web_url' do
    it 'returns the canonical URL' do
      expect(group.web_url).to include("groups/#{group.name}")
    end
  end
274 275

  describe 'nested group' do
276
    subject { build(:group, :nested) }
277 278 279 280

    it { is_expected.to be_valid }
    it { expect(subject.parent).to be_kind_of(Group) }
  end
281
end