user_spec.rb 14.2 KB
Newer Older
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
1
2
3
4
# == Schema Information
#
# Table name: users
#
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
5
6
7
8
9
10
11
12
13
14
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
42
43
44
45
46
#  id                       :integer          not null, primary key
#  email                    :string(255)      default(""), not null
#  encrypted_password       :string(255)      default(""), not null
#  reset_password_token     :string(255)
#  reset_password_sent_at   :datetime
#  remember_created_at      :datetime
#  sign_in_count            :integer          default(0)
#  current_sign_in_at       :datetime
#  last_sign_in_at          :datetime
#  current_sign_in_ip       :string(255)
#  last_sign_in_ip          :string(255)
#  created_at               :datetime
#  updated_at               :datetime
#  name                     :string(255)
#  admin                    :boolean          default(FALSE), not null
#  projects_limit           :integer          default(10)
#  skype                    :string(255)      default(""), not null
#  linkedin                 :string(255)      default(""), not null
#  twitter                  :string(255)      default(""), not null
#  authentication_token     :string(255)
#  theme_id                 :integer          default(1), not null
#  bio                      :string(255)
#  failed_attempts          :integer          default(0)
#  locked_at                :datetime
#  extern_uid               :string(255)
#  provider                 :string(255)
#  username                 :string(255)
#  can_create_group         :boolean          default(TRUE), not null
#  can_create_team          :boolean          default(TRUE), not null
#  state                    :string(255)
#  color_scheme_id          :integer          default(1), not null
#  notification_level       :integer          default(1), not null
#  password_expires_at      :datetime
#  created_by_id            :integer
#  last_credential_check_at :datetime
#  avatar                   :string(255)
#  confirmation_token       :string(255)
#  confirmed_at             :datetime
#  confirmation_sent_at     :datetime
#  unconfirmed_email        :string(255)
#  hide_no_ssh_key          :boolean          default(FALSE)
#  website_url              :string(255)      default(""), not null
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
47
48
#

gitlabhq's avatar
gitlabhq committed
49
50
51
52
require 'spec_helper'

describe User do
  describe "Associations" do
53
    it { should have_one(:namespace) }
54
    it { should have_many(:snippets).class_name('Snippet').dependent(:destroy) }
55
    it { should have_many(:project_members).dependent(:destroy) }
56
    it { should have_many(:groups) }
57
58
59
    it { should have_many(:keys).dependent(:destroy) }
    it { should have_many(:events).class_name('Event').dependent(:destroy) }
    it { should have_many(:recent_events).class_name('Event') }
60
    it { should have_many(:issues).dependent(:destroy) }
61
    it { should have_many(:notes).dependent(:destroy) }
62
63
64
    it { should have_many(:assigned_issues).dependent(:destroy) }
    it { should have_many(:merge_requests).dependent(:destroy) }
    it { should have_many(:assigned_merge_requests).dependent(:destroy) }
65
66
  end

67
68
69
  describe "Mass assignment" do
  end

70
  describe 'validations' do
71
    it { should validate_presence_of(:username) }
72
73
74
75
76
77
    it { should validate_presence_of(:projects_limit) }
    it { should validate_numericality_of(:projects_limit) }
    it { should allow_value(0).for(:projects_limit) }
    it { should_not allow_value(-1).for(:projects_limit) }

    it { should ensure_length_of(:bio).is_within(0..255) }
78
79
80
81
82
83

    describe 'email' do
      it 'accepts info@example.com' do
        user = build(:user, email: 'info@example.com')
        expect(user).to be_valid
      end
84

85
86
87
88
89
      it 'accepts info+test@example.com' do
        user = build(:user, email: 'info+test@example.com')
        expect(user).to be_valid
      end

90
91
92
93
94
      it "accepts o'reilly@example.com" do
        user = build(:user, email: "o'reilly@example.com")
        expect(user).to be_valid
      end

95
96
97
98
99
100
101
102
103
      it 'rejects test@test@example.com' do
        user = build(:user, email: 'test@test@example.com')
        expect(user).to be_invalid
      end

      it 'rejects mailto:test@example.com' do
        user = build(:user, email: 'mailto:test@example.com')
        expect(user).to be_invalid
      end
104
105
106
107
108

      it "rejects lol!'+=?><#$%^&*()@gmail.com" do
        user = build(:user, email: "lol!'+=?><#$%^&*()@gmail.com")
        expect(user).to be_invalid
      end
109
    end
gitlabhq's avatar
gitlabhq committed
110
111
112
113
114
  end

  describe "Respond to" do
    it { should respond_to(:is_admin?) }
    it { should respond_to(:name) }
Nihad Abbasov's avatar
Nihad Abbasov committed
115
    it { should respond_to(:private_token) }
gitlabhq's avatar
gitlabhq committed
116
117
  end

118
119
120
121
122
123
124
125
  describe '#generate_password' do
    it "should execute callback when force_random_password specified" do
      user = build(:user, force_random_password: true)
      user.should_receive(:generate_password)
      user.save
    end

    it "should not generate password by default" do
126
127
      user = create(:user, password: 'abcdefghe')
      user.password.should == 'abcdefghe'
128
    end
129

130
131
132
133
134
    it "should generate password when forcing random password" do
      Devise.stub(:friendly_token).and_return('123456789')
      user = create(:user, password: 'abcdefg', force_random_password: true)
      user.password.should == '12345678'
    end
135
136
  end

137
138
  describe 'authentication token' do
    it "should have authentication token" do
139
      user = create(:user)
140
141
      user.authentication_token.should_not be_blank
    end
Nihad Abbasov's avatar
Nihad Abbasov committed
142
  end
143
144
145
146
147

  describe 'projects' do
    before do
      @user = create :user
      @project = create :project, namespace: @user.namespace
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
148
149
      @project_2 = create :project, group: create(:group) # Grant MASTER access to the user
      @project_3 = create :project, group: create(:group) # Grant DEVELOPER access to the user
150

151
152
      @project_2.team << [@user, :master]
      @project_3.team << [@user, :developer]
153
154
155
    end

    it { @user.authorized_projects.should include(@project) }
156
157
    it { @user.authorized_projects.should include(@project_2) }
    it { @user.authorized_projects.should include(@project_3) }
158
    it { @user.owned_projects.should include(@project) }
159
160
    it { @user.owned_projects.should_not include(@project_2) }
    it { @user.owned_projects.should_not include(@project_3) }
161
    it { @user.personal_projects.should include(@project) }
162
163
    it { @user.personal_projects.should_not include(@project_2) }
    it { @user.personal_projects.should_not include(@project_3) }
164
165
166
167
168
  end

  describe 'groups' do
    before do
      @user = create :user
169
170
      @group = create :group
      @group.add_owner(@user)
171
172
173
174
175
176
177
    end

    it { @user.several_namespaces?.should be_true }
    it { @user.authorized_groups.should == [@group] }
    it { @user.owned_groups.should == [@group] }
  end

178
179
180
181
  describe 'group multiple owners' do
    before do
      @user = create :user
      @user2 = create :user
182
183
      @group = create :group
      @group.add_owner(@user)
184

185
      @group.add_user(@user2, GroupMember::OWNER)
186
187
188
189
190
    end

    it { @user2.several_namespaces?.should be_true }
  end

191
192
193
194
195
196
197
198
199
200
201
202
203
204
  describe 'namespaced' do
    before do
      @user = create :user
      @project = create :project, namespace: @user.namespace
    end

    it { @user.several_namespaces?.should be_false }
  end

  describe 'blocking user' do
    let(:user) { create(:user, name: 'John Smith') }

    it "should block user" do
      user.block
205
      user.blocked?.should be_true
206
207
208
209
210
    end
  end

  describe 'filter' do
    before do
211
      User.delete_all
212
213
      @user = create :user
      @admin = create :user, admin: true
214
      @blocked = create :user, state: :blocked
215
216
217
218
    end

    it { User.filter("admins").should == [@admin] }
    it { User.filter("blocked").should == [@blocked] }
219
220
    it { User.filter("wop").should include(@user, @admin, @blocked) }
    it { User.filter(nil).should include(@user, @admin) }
221
222
223
224
  end

  describe :not_in_project do
    before do
225
      User.delete_all
226
227
228
229
      @user = create :user
      @project = create :project
    end

230
    it { User.not_in_project(@project).should include(@user, @project.owner) }
231
  end
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
232

233
234
235
  describe 'user creation' do
    describe 'normal user' do
      let(:user) { create(:user, name: 'John Smith') }
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
236

237
238
239
240
241
242
      it { user.is_admin?.should be_false }
      it { user.require_ssh_key?.should be_true }
      it { user.can_create_group?.should be_true }
      it { user.can_create_project?.should be_true }
      it { user.first_name.should == 'John' }
    end
243

Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
244
    describe 'with defaults' do
245
      let(:user) { User.new }
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
246

Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
247
248
249
250
      it "should apply defaults to user" do
        user.projects_limit.should == Gitlab.config.gitlab.default_projects_limit
        user.can_create_group.should == Gitlab.config.gitlab.default_can_create_group
        user.theme_id.should == Gitlab.config.gitlab.default_theme
251
252
253
      end
    end

Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
254
255
    describe 'with default overrides' do
      let(:user) { User.new(projects_limit: 123, can_create_group: false, can_create_team: true, theme_id: Gitlab::Theme::BASIC) }
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
256

Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
257
258
259
260
      it "should apply defaults to user" do
        user.projects_limit.should == 123
        user.can_create_group.should be_false
        user.theme_id.should == Gitlab::Theme::BASIC
261
      end
262
263
    end
  end
264

265
266
267
268
269
270
271
272
273
  describe 'search' do
    let(:user1) { create(:user, username: 'James', email: 'james@testing.com') }
    let(:user2) { create(:user, username: 'jameson', email: 'jameson@example.com') }

    it "should be case insensitive" do
      User.search(user1.username.upcase).to_a.should == [user1]
      User.search(user1.username.downcase).to_a.should == [user1]
      User.search(user2.username.upcase).to_a.should == [user2]
      User.search(user2.username.downcase).to_a.should == [user2]
274
275
      User.search(user1.username.downcase).to_a.count.should == 2
      User.search(user2.username.downcase).to_a.count.should == 1
276
277
278
    end
  end

279
  describe 'by_username_or_id' do
Dmitriy Zaporozhets's avatar
Dmitriy Zaporozhets committed
280
281
    let(:user1) { create(:user, username: 'foo') }

282
283
284
285
286
287
288
    it "should get the correct user" do
      User.by_username_or_id(user1.id).should == user1
      User.by_username_or_id('foo').should == user1
      User.by_username_or_id(-1).should be_nil
      User.by_username_or_id('bar').should be_nil
    end
  end
GitLab's avatar
GitLab committed
289
290
291
292
293
294
295
296
297
298

  describe 'all_ssh_keys' do
    it { should have_many(:keys).dependent(:destroy) }

    it "should have all ssh keys" do
      user = create :user
      key = create :key, key: "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQD33bWLBxu48Sev9Fert1yzEO4WGcWglWF7K/AwblIUFselOt/QdOL9DSjpQGxLagO1s9wl53STIO8qGS4Ms0EJZyIXOEFMjFJ5xmjSy+S37By4sG7SsltQEHMxtbtFOaW5LV2wCrX+rUsRNqLMamZjgjcPO0/EgGCXIGMAYW4O7cwGZdXWYIhQ1Vwy+CsVMDdPkPgBXqK7nR/ey8KMs8ho5fMNgB5hBw/AL9fNGhRw3QTD6Q12Nkhl4VZES2EsZqlpNnJttnPdp847DUsT6yuLRlfiQfz5Cn9ysHFdXObMN5VYIiPFwHeYCZp1X2S4fDZooRE8uOLTfxWHPXwrhqSH", user_id: user.id

      user.all_ssh_keys.should include(key.key)
    end
GitLab's avatar
GitLab committed
299
  end
300

301
302
303
304
305
306
307
308
309
310
311
312
313
  describe :avatar_type do
    let(:user) { create(:user) }

    it "should be true if avatar is image" do
      user.update_attribute(:avatar, 'uploads/avatar.png')
      user.avatar_type.should be_true
    end

    it "should be false if avatar is html page" do
      user.update_attribute(:avatar, 'uploads/avatar.html')
      user.avatar_type.should == ["only images allowed"]
    end
  end
Jerome Dalbert's avatar
Jerome Dalbert committed
314

315
316
317
  describe :requires_ldap_check? do
    let(:user) { User.new }

318
319
320
321
    it 'is false when LDAP is disabled' do
      # Create a condition which would otherwise cause 'true' to be returned
      user.stub(ldap_user?: true)
      user.last_credential_check_at = nil
322
323
324
      expect(user.requires_ldap_check?).to be_false
    end

325
326
    context 'when LDAP is enabled' do
      before { Gitlab.config.ldap.stub(enabled: true) }
327

328
329
330
      it 'is false for non-LDAP users' do
        user.stub(ldap_user?: false)
        expect(user.requires_ldap_check?).to be_false
331
332
      end

333
334
335
336
337
338
339
340
341
342
343
344
      context 'and when the user is an LDAP user' do
        before { user.stub(ldap_user?: true) }

        it 'is true when the user has never had an LDAP check before' do
          user.last_credential_check_at = nil
          expect(user.requires_ldap_check?).to be_true
        end

        it 'is true when the last LDAP check happened over 1 hour ago' do
          user.last_credential_check_at = 2.hours.ago
          expect(user.requires_ldap_check?).to be_true
        end
345
346
347
348
      end
    end
  end

Jerome Dalbert's avatar
Jerome Dalbert committed
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
380
381
382
383
384
385
386
387
  describe '#full_website_url' do
    let(:user) { create(:user) }

    it 'begins with http if website url omits it' do
      user.website_url = 'test.com'

      expect(user.full_website_url).to eq 'http://test.com'
    end

    it 'begins with http if website url begins with http' do
      user.website_url = 'http://test.com'

      expect(user.full_website_url).to eq 'http://test.com'
    end

    it 'begins with https if website url begins with https' do
      user.website_url = 'https://test.com'

      expect(user.full_website_url).to eq 'https://test.com'
    end
  end

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

    it 'does not begin with http if website url omits it' do
      user.website_url = 'test.com'

      expect(user.short_website_url).to eq 'test.com'
    end

    it 'does not begin with http if website url begins with http' do
      user.website_url = 'http://test.com'

      expect(user.short_website_url).to eq 'test.com'
    end

    it 'does not begin with https if website url begins with https' do
      user.website_url = 'https://test.com'
388

Jerome Dalbert's avatar
Jerome Dalbert committed
389
390
      expect(user.short_website_url).to eq 'test.com'
    end
GitLab's avatar
GitLab committed
391
  end
Ciro Santilli's avatar
Ciro Santilli committed
392

393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
  describe "#starred?" do
    it "determines if user starred a project" do
      user = create :user
      project1 = create :project, :public
      project2 = create :project, :public

      expect(user.starred?(project1)).to be_false
      expect(user.starred?(project2)).to be_false

      star1 = UsersStarProject.create!(project: project1, user: user)
      expect(user.starred?(project1)).to be_true
      expect(user.starred?(project2)).to be_false

      star2 = UsersStarProject.create!(project: project2, user: user)
      expect(user.starred?(project1)).to be_true
      expect(user.starred?(project2)).to be_true

      star1.destroy
      expect(user.starred?(project1)).to be_false
      expect(user.starred?(project2)).to be_true

      star2.destroy
      expect(user.starred?(project1)).to be_false
      expect(user.starred?(project2)).to be_false
    end
  end

Ciro Santilli's avatar
Ciro Santilli committed
420
421
422
423
424
425
426
427
428
429
430
431
  describe "#toggle_star" do
    it "toggles stars" do
      user = create :user
      project = create :project, :public

      expect(user.starred?(project)).to be_false
      user.toggle_star(project)
      expect(user.starred?(project)).to be_true
      user.toggle_star(project)
      expect(user.starred?(project)).to be_false
    end
  end
gitlabhq's avatar
gitlabhq committed
432
end