BigW Consortium Gitlab

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

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

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

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

44 45 46 47 48 49 50 51 52 53 54 55 56 57
  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

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

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

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

Douwe Maan committed
84
      it{ is_expected.to eq([group]) }
85 86 87
    end

    describe 'public_and_internal_only' do
Douwe Maan committed
88
      subject { described_class.public_and_internal_only.to_a }
89

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

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

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

  describe :human_name do
105
    it { expect(group.human_name).to eq(group.name) }
106
  end
107 108 109

  describe :add_users do
    let(:user) { create(:user) }
110
    before { group.add_user(user, GroupMember::MASTER) }
111

112
    it { expect(group.group_members.masters.map(&:user)).to include(user) }
113
  end
114 115 116

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

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

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

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

    it "should be false if avatar is html page" do
      group.update_attribute(:avatar, 'uploads/avatar.html')
138
      expect(group.avatar_type).to eq(["only images allowed"])
Steven Thonus committed
139 140
    end
  end
141 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

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

  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

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

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