BigW Consortium Gitlab

group_spec.rb 3.77 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 8
    it { is_expected.to have_many :projects }
    it { is_expected.to have_many :group_members }
9 10
  end

11 12 13 14 15 16 17 18 19 20 21 22 23 24
  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

25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43
  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

44
  describe 'scopes' do
45 46
    let!(:private_group)  { create(:group, :private)  }
    let!(:internal_group) { create(:group, :internal) }
47 48

    describe 'public_only' do
49
      subject { described_class.public_only.to_a }
50

Douwe Maan committed
51
      it{ is_expected.to eq([group]) }
52 53 54
    end

    describe 'public_and_internal_only' do
Douwe Maan committed
55
      subject { described_class.public_and_internal_only.to_a }
56

Douwe Maan committed
57
      it{ is_expected.to match_array([group, internal_group]) }
58 59 60
    end
  end

61 62 63 64 65
  describe '#to_reference' do
    it 'returns a String reference to the object' do
      expect(group.to_reference).to eq "@#{group.name}"
    end
  end
66 67

  describe :users do
68
    it { expect(group.users).to eq(group.owners) }
69 70 71
  end

  describe :human_name do
72
    it { expect(group.human_name).to eq(group.name) }
73
  end
74 75 76

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

79
    it { expect(group.group_members.masters.map(&:user)).to include(user) }
80
  end
81 82 83

  describe :add_users do
    let(:user) { create(:user) }
84
    before { group.add_users([user.id], GroupMember::GUEST) }
85 86

    it "should update the group permission" do
87
      expect(group.group_members.guests.map(&:user)).to include(user)
88
      group.add_users([user.id], GroupMember::DEVELOPER)
89 90
      expect(group.group_members.developers.map(&:user)).to include(user)
      expect(group.group_members.guests.map(&:user)).not_to include(user)
91 92
    end
  end
Steven Thonus committed
93 94 95

  describe :avatar_type do
    let(:user) { create(:user) }
96
    before { group.add_user(user, GroupMember::MASTER) }
Steven Thonus committed
97 98 99

    it "should be true if avatar is image" do
      group.update_attribute(:avatar, 'uploads/avatar.png')
100
      expect(group.avatar_type).to be_truthy
Steven Thonus committed
101 102 103 104
    end

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

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