##// END OF EJS Templates
jro_apps » redmine
RSS
remove unneeded Relation#all from UserTest...
Toshi MARUYAMA -
r12439:28b1b1ea9011
parent child
Show More
Side by Side Unified
Context file:
r12439:28b1b1ea9011 Loading diff...:
Show file before | Show file after | Hide comments
@@ -1,1154 +1,1154
1 1 # Redmine - project management software
2 2 # Copyright (C) 2006-2013 Jean-Philippe Lang
3 3 #
4 4 # This program is free software; you can redistribute it and/or
5 5 # modify it under the terms of the GNU General Public License
6 6 # as published by the Free Software Foundation; either version 2
7 7 # of the License, or (at your option) any later version.
8 8 #
9 9 # This program is distributed in the hope that it will be useful,
10 10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
11 11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 12 # GNU General Public License for more details.
13 13 #
14 14 # You should have received a copy of the GNU General Public License
15 15 # along with this program; if not, write to the Free Software
16 16 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17 17
18 18 require File.expand_path('../../test_helper', __FILE__)
19 19
20 20 class UserTest < ActiveSupport::TestCase
21 21 fixtures :users, :members, :projects, :roles, :member_roles, :auth_sources,
22 22 :trackers, :issue_statuses,
23 23 :projects_trackers,
24 24 :watchers,
25 25 :issue_categories, :enumerations, :issues,
26 26 :journals, :journal_details,
27 27 :groups_users,
28 28 :enabled_modules
29 29
30 30 def setup
31 31 @admin = User.find(1)
32 32 @jsmith = User.find(2)
33 33 @dlopper = User.find(3)
34 34 end
35 35
36 36 def test_sorted_scope_should_sort_user_by_display_name
37 37 assert_equal User.all.map(&:name).map(&:downcase).sort,
38 User.sorted.all.map(&:name).map(&:downcase)
38 User.sorted.map(&:name).map(&:downcase)
39 39 end
40 40
41 41 def test_generate
42 42 User.generate!(:firstname => 'Testing connection')
43 43 User.generate!(:firstname => 'Testing connection')
44 44 assert_equal 2, User.where(:firstname => 'Testing connection').count
45 45 end
46 46
47 47 def test_truth
48 48 assert_kind_of User, @jsmith
49 49 end
50 50
51 51 def test_mail_should_be_stripped
52 52 u = User.new
53 53 u.mail = " foo@bar.com "
54 54 assert_equal "foo@bar.com", u.mail
55 55 end
56 56
57 57 def test_mail_validation
58 58 u = User.new
59 59 u.mail = ''
60 60 assert !u.valid?
61 61 assert_include I18n.translate('activerecord.errors.messages.blank'), u.errors[:mail]
62 62 end
63 63
64 64 def test_login_length_validation
65 65 user = User.new(:firstname => "new", :lastname => "user", :mail => "newuser@somenet.foo")
66 66 user.login = "x" * (User::LOGIN_LENGTH_LIMIT+1)
67 67 assert !user.valid?
68 68
69 69 user.login = "x" * (User::LOGIN_LENGTH_LIMIT)
70 70 assert user.valid?
71 71 assert user.save
72 72 end
73 73
74 74 def test_generate_password_should_respect_minimum_password_length
75 75 with_settings :password_min_length => 15 do
76 76 user = User.generate!(:generate_password => true)
77 77 assert user.password.length >= 15
78 78 end
79 79 end
80 80
81 81 def test_generate_password_should_not_generate_password_with_less_than_10_characters
82 82 with_settings :password_min_length => 4 do
83 83 user = User.generate!(:generate_password => true)
84 84 assert user.password.length >= 10
85 85 end
86 86 end
87 87
88 88 def test_generate_password_on_create_should_set_password
89 89 user = User.new(:firstname => "new", :lastname => "user", :mail => "newuser@somenet.foo")
90 90 user.login = "newuser"
91 91 user.generate_password = true
92 92 assert user.save
93 93
94 94 password = user.password
95 95 assert user.check_password?(password)
96 96 end
97 97
98 98 def test_generate_password_on_update_should_update_password
99 99 user = User.find(2)
100 100 hash = user.hashed_password
101 101 user.generate_password = true
102 102 assert user.save
103 103
104 104 password = user.password
105 105 assert user.check_password?(password)
106 106 assert_not_equal hash, user.reload.hashed_password
107 107 end
108 108
109 109 def test_create
110 110 user = User.new(:firstname => "new", :lastname => "user", :mail => "newuser@somenet.foo")
111 111
112 112 user.login = "jsmith"
113 113 user.password, user.password_confirmation = "password", "password"
114 114 # login uniqueness
115 115 assert !user.save
116 116 assert_equal 1, user.errors.count
117 117
118 118 user.login = "newuser"
119 119 user.password, user.password_confirmation = "password", "pass"
120 120 # password confirmation
121 121 assert !user.save
122 122 assert_equal 1, user.errors.count
123 123
124 124 user.password, user.password_confirmation = "password", "password"
125 125 assert user.save
126 126 end
127 127
128 128 def test_user_before_create_should_set_the_mail_notification_to_the_default_setting
129 129 @user1 = User.generate!
130 130 assert_equal 'only_my_events', @user1.mail_notification
131 131 with_settings :default_notification_option => 'all' do
132 132 @user2 = User.generate!
133 133 assert_equal 'all', @user2.mail_notification
134 134 end
135 135 end
136 136
137 137 def test_user_login_should_be_case_insensitive
138 138 u = User.new(:firstname => "new", :lastname => "user", :mail => "newuser@somenet.foo")
139 139 u.login = 'newuser'
140 140 u.password, u.password_confirmation = "password", "password"
141 141 assert u.save
142 142 u = User.new(:firstname => "Similar", :lastname => "User",
143 143 :mail => "similaruser@somenet.foo")
144 144 u.login = 'NewUser'
145 145 u.password, u.password_confirmation = "password", "password"
146 146 assert !u.save
147 147 assert_include I18n.translate('activerecord.errors.messages.taken'), u.errors[:login]
148 148 end
149 149
150 150 def test_mail_uniqueness_should_not_be_case_sensitive
151 151 u = User.new(:firstname => "new", :lastname => "user", :mail => "newuser@somenet.foo")
152 152 u.login = 'newuser1'
153 153 u.password, u.password_confirmation = "password", "password"
154 154 assert u.save
155 155
156 156 u = User.new(:firstname => "new", :lastname => "user", :mail => "newUser@Somenet.foo")
157 157 u.login = 'newuser2'
158 158 u.password, u.password_confirmation = "password", "password"
159 159 assert !u.save
160 160 assert_include I18n.translate('activerecord.errors.messages.taken'), u.errors[:mail]
161 161 end
162 162
163 163 def test_update
164 164 assert_equal "admin", @admin.login
165 165 @admin.login = "john"
166 166 assert @admin.save, @admin.errors.full_messages.join("; ")
167 167 @admin.reload
168 168 assert_equal "john", @admin.login
169 169 end
170 170
171 171 def test_update_should_not_fail_for_legacy_user_with_different_case_logins
172 172 u1 = User.new(:firstname => "new", :lastname => "user", :mail => "newuser1@somenet.foo")
173 173 u1.login = 'newuser1'
174 174 assert u1.save
175 175
176 176 u2 = User.new(:firstname => "new", :lastname => "user", :mail => "newuser2@somenet.foo")
177 177 u2.login = 'newuser1'
178 178 assert u2.save(:validate => false)
179 179
180 180 user = User.find(u2.id)
181 181 user.firstname = "firstname"
182 182 assert user.save, "Save failed"
183 183 end
184 184
185 185 def test_destroy_should_delete_members_and_roles
186 186 members = Member.where(:user_id => 2)
187 187 ms = members.count
188 188 rs = members.collect(&:roles).flatten.size
189 189 assert ms > 0
190 190 assert rs > 0
191 191 assert_difference 'Member.count', - ms do
192 192 assert_difference 'MemberRole.count', - rs do
193 193 User.find(2).destroy
194 194 end
195 195 end
196 196 assert_nil User.find_by_id(2)
197 197 assert_equal 0, Member.where(:user_id => 2).count
198 198 end
199 199
200 200 def test_destroy_should_update_attachments
201 201 attachment = Attachment.create!(:container => Project.find(1),
202 202 :file => uploaded_test_file("testfile.txt", "text/plain"),
203 203 :author_id => 2)
204 204
205 205 User.find(2).destroy
206 206 assert_nil User.find_by_id(2)
207 207 assert_equal User.anonymous, attachment.reload.author
208 208 end
209 209
210 210 def test_destroy_should_update_comments
211 211 comment = Comment.create!(
212 212 :commented => News.create!(:project_id => 1,
213 213 :author_id => 1, :title => 'foo', :description => 'foo'),
214 214 :author => User.find(2),
215 215 :comments => 'foo'
216 216 )
217 217
218 218 User.find(2).destroy
219 219 assert_nil User.find_by_id(2)
220 220 assert_equal User.anonymous, comment.reload.author
221 221 end
222 222
223 223 def test_destroy_should_update_issues
224 224 issue = Issue.create!(:project_id => 1, :author_id => 2,
225 225 :tracker_id => 1, :subject => 'foo')
226 226
227 227 User.find(2).destroy
228 228 assert_nil User.find_by_id(2)
229 229 assert_equal User.anonymous, issue.reload.author
230 230 end
231 231
232 232 def test_destroy_should_unassign_issues
233 233 issue = Issue.create!(:project_id => 1, :author_id => 1,
234 234 :tracker_id => 1, :subject => 'foo', :assigned_to_id => 2)
235 235
236 236 User.find(2).destroy
237 237 assert_nil User.find_by_id(2)
238 238 assert_nil issue.reload.assigned_to
239 239 end
240 240
241 241 def test_destroy_should_update_journals
242 242 issue = Issue.create!(:project_id => 1, :author_id => 2,
243 243 :tracker_id => 1, :subject => 'foo')
244 244 issue.init_journal(User.find(2), "update")
245 245 issue.save!
246 246
247 247 User.find(2).destroy
248 248 assert_nil User.find_by_id(2)
249 249 assert_equal User.anonymous, issue.journals.first.reload.user
250 250 end
251 251
252 252 def test_destroy_should_update_journal_details_old_value
253 253 issue = Issue.create!(:project_id => 1, :author_id => 1,
254 254 :tracker_id => 1, :subject => 'foo', :assigned_to_id => 2)
255 255 issue.init_journal(User.find(1), "update")
256 256 issue.assigned_to_id = nil
257 257 assert_difference 'JournalDetail.count' do
258 258 issue.save!
259 259 end
260 260 journal_detail = JournalDetail.order('id DESC').first
261 261 assert_equal '2', journal_detail.old_value
262 262
263 263 User.find(2).destroy
264 264 assert_nil User.find_by_id(2)
265 265 assert_equal User.anonymous.id.to_s, journal_detail.reload.old_value
266 266 end
267 267
268 268 def test_destroy_should_update_journal_details_value
269 269 issue = Issue.create!(:project_id => 1, :author_id => 1,
270 270 :tracker_id => 1, :subject => 'foo')
271 271 issue.init_journal(User.find(1), "update")
272 272 issue.assigned_to_id = 2
273 273 assert_difference 'JournalDetail.count' do
274 274 issue.save!
275 275 end
276 276 journal_detail = JournalDetail.order('id DESC').first
277 277 assert_equal '2', journal_detail.value
278 278
279 279 User.find(2).destroy
280 280 assert_nil User.find_by_id(2)
281 281 assert_equal User.anonymous.id.to_s, journal_detail.reload.value
282 282 end
283 283
284 284 def test_destroy_should_update_messages
285 285 board = Board.create!(:project_id => 1, :name => 'Board', :description => 'Board')
286 286 message = Message.create!(:board_id => board.id, :author_id => 2,
287 287 :subject => 'foo', :content => 'foo')
288 288 User.find(2).destroy
289 289 assert_nil User.find_by_id(2)
290 290 assert_equal User.anonymous, message.reload.author
291 291 end
292 292
293 293 def test_destroy_should_update_news
294 294 news = News.create!(:project_id => 1, :author_id => 2,
295 295 :title => 'foo', :description => 'foo')
296 296 User.find(2).destroy
297 297 assert_nil User.find_by_id(2)
298 298 assert_equal User.anonymous, news.reload.author
299 299 end
300 300
301 301 def test_destroy_should_delete_private_queries
302 302 query = Query.new(:name => 'foo', :visibility => Query::VISIBILITY_PRIVATE)
303 303 query.project_id = 1
304 304 query.user_id = 2
305 305 query.save!
306 306
307 307 User.find(2).destroy
308 308 assert_nil User.find_by_id(2)
309 309 assert_nil Query.find_by_id(query.id)
310 310 end
311 311
312 312 def test_destroy_should_update_public_queries
313 313 query = Query.new(:name => 'foo', :visibility => Query::VISIBILITY_PUBLIC)
314 314 query.project_id = 1
315 315 query.user_id = 2
316 316 query.save!
317 317
318 318 User.find(2).destroy
319 319 assert_nil User.find_by_id(2)
320 320 assert_equal User.anonymous, query.reload.user
321 321 end
322 322
323 323 def test_destroy_should_update_time_entries
324 324 entry = TimeEntry.new(:hours => '2', :spent_on => Date.today,
325 325 :activity => TimeEntryActivity.create!(:name => 'foo'))
326 326 entry.project_id = 1
327 327 entry.user_id = 2
328 328 entry.save!
329 329
330 330 User.find(2).destroy
331 331 assert_nil User.find_by_id(2)
332 332 assert_equal User.anonymous, entry.reload.user
333 333 end
334 334
335 335 def test_destroy_should_delete_tokens
336 336 token = Token.create!(:user_id => 2, :value => 'foo')
337 337
338 338 User.find(2).destroy
339 339 assert_nil User.find_by_id(2)
340 340 assert_nil Token.find_by_id(token.id)
341 341 end
342 342
343 343 def test_destroy_should_delete_watchers
344 344 issue = Issue.create!(:project_id => 1, :author_id => 1,
345 345 :tracker_id => 1, :subject => 'foo')
346 346 watcher = Watcher.create!(:user_id => 2, :watchable => issue)
347 347
348 348 User.find(2).destroy
349 349 assert_nil User.find_by_id(2)
350 350 assert_nil Watcher.find_by_id(watcher.id)
351 351 end
352 352
353 353 def test_destroy_should_update_wiki_contents
354 354 wiki_content = WikiContent.create!(
355 355 :text => 'foo',
356 356 :author_id => 2,
357 357 :page => WikiPage.create!(:title => 'Foo',
358 358 :wiki => Wiki.create!(:project_id => 3,
359 359 :start_page => 'Start'))
360 360 )
361 361 wiki_content.text = 'bar'
362 362 assert_difference 'WikiContent::Version.count' do
363 363 wiki_content.save!
364 364 end
365 365
366 366 User.find(2).destroy
367 367 assert_nil User.find_by_id(2)
368 368 assert_equal User.anonymous, wiki_content.reload.author
369 369 wiki_content.versions.each do |version|
370 370 assert_equal User.anonymous, version.reload.author
371 371 end
372 372 end
373 373
374 374 def test_destroy_should_nullify_issue_categories
375 375 category = IssueCategory.create!(:project_id => 1, :assigned_to_id => 2, :name => 'foo')
376 376
377 377 User.find(2).destroy
378 378 assert_nil User.find_by_id(2)
379 379 assert_nil category.reload.assigned_to_id
380 380 end
381 381
382 382 def test_destroy_should_nullify_changesets
383 383 changeset = Changeset.create!(
384 384 :repository => Repository::Subversion.create!(
385 385 :project_id => 1,
386 386 :url => 'file:///tmp',
387 387 :identifier => 'tmp'
388 388 ),
389 389 :revision => '12',
390 390 :committed_on => Time.now,
391 391 :committer => 'jsmith'
392 392 )
393 393 assert_equal 2, changeset.user_id
394 394
395 395 User.find(2).destroy
396 396 assert_nil User.find_by_id(2)
397 397 assert_nil changeset.reload.user_id
398 398 end
399 399
400 400 def test_anonymous_user_should_not_be_destroyable
401 401 assert_no_difference 'User.count' do
402 402 assert_equal false, User.anonymous.destroy
403 403 end
404 404 end
405 405
406 406 def test_validate_login_presence
407 407 @admin.login = ""
408 408 assert !@admin.save
409 409 assert_equal 1, @admin.errors.count
410 410 end
411 411
412 412 def test_validate_mail_notification_inclusion
413 413 u = User.new
414 414 u.mail_notification = 'foo'
415 415 u.save
416 416 assert_not_equal [], u.errors[:mail_notification]
417 417 end
418 418
419 419 def test_password
420 420 user = User.try_to_login("admin", "admin")
421 421 assert_kind_of User, user
422 422 assert_equal "admin", user.login
423 423 user.password = "hello123"
424 424 assert user.save
425 425
426 426 user = User.try_to_login("admin", "hello123")
427 427 assert_kind_of User, user
428 428 assert_equal "admin", user.login
429 429 end
430 430
431 431 def test_validate_password_length
432 432 with_settings :password_min_length => '100' do
433 433 user = User.new(:firstname => "new100",
434 434 :lastname => "user100", :mail => "newuser100@somenet.foo")
435 435 user.login = "newuser100"
436 436 user.password, user.password_confirmation = "password100", "password100"
437 437 assert !user.save
438 438 assert_equal 1, user.errors.count
439 439 end
440 440 end
441 441
442 442 def test_name_format
443 443 assert_equal 'John S.', @jsmith.name(:firstname_lastinitial)
444 444 assert_equal 'Smith, John', @jsmith.name(:lastname_coma_firstname)
445 445 assert_equal 'J. Smith', @jsmith.name(:firstinitial_lastname)
446 446 assert_equal 'J.-P. Lang', User.new(:firstname => 'Jean-Philippe', :lastname => 'Lang').name(:firstinitial_lastname)
447 447 end
448 448
449 449 def test_name_should_use_setting_as_default_format
450 450 with_settings :user_format => :firstname_lastname do
451 451 assert_equal 'John Smith', @jsmith.reload.name
452 452 end
453 453 with_settings :user_format => :username do
454 454 assert_equal 'jsmith', @jsmith.reload.name
455 455 end
456 456 with_settings :user_format => :lastname do
457 457 assert_equal 'Smith', @jsmith.reload.name
458 458 end
459 459 end
460 460
461 461 def test_today_should_return_the_day_according_to_user_time_zone
462 462 preference = User.find(1).pref
463 463 date = Date.new(2012, 05, 15)
464 464 time = Time.gm(2012, 05, 15, 23, 30).utc # 2012-05-15 23:30 UTC
465 465 Date.stubs(:today).returns(date)
466 466 Time.stubs(:now).returns(time)
467 467
468 468 preference.update_attribute :time_zone, 'Baku' # UTC+4
469 469 assert_equal '2012-05-16', User.find(1).today.to_s
470 470
471 471 preference.update_attribute :time_zone, 'La Paz' # UTC-4
472 472 assert_equal '2012-05-15', User.find(1).today.to_s
473 473
474 474 preference.update_attribute :time_zone, ''
475 475 assert_equal '2012-05-15', User.find(1).today.to_s
476 476 end
477 477
478 478 def test_time_to_date_should_return_the_date_according_to_user_time_zone
479 479 preference = User.find(1).pref
480 480 time = Time.gm(2012, 05, 15, 23, 30).utc # 2012-05-15 23:30 UTC
481 481
482 482 preference.update_attribute :time_zone, 'Baku' # UTC+4
483 483 assert_equal '2012-05-16', User.find(1).time_to_date(time).to_s
484 484
485 485 preference.update_attribute :time_zone, 'La Paz' # UTC-4
486 486 assert_equal '2012-05-15', User.find(1).time_to_date(time).to_s
487 487
488 488 preference.update_attribute :time_zone, ''
489 489 assert_equal '2012-05-15', User.find(1).time_to_date(time).to_s
490 490 end
491 491
492 492 def test_fields_for_order_statement_should_return_fields_according_user_format_setting
493 493 with_settings :user_format => 'lastname_coma_firstname' do
494 494 assert_equal ['users.lastname', 'users.firstname', 'users.id'],
495 495 User.fields_for_order_statement
496 496 end
497 497 end
498 498
499 499 def test_fields_for_order_statement_width_table_name_should_prepend_table_name
500 500 with_settings :user_format => 'lastname_firstname' do
501 501 assert_equal ['authors.lastname', 'authors.firstname', 'authors.id'],
502 502 User.fields_for_order_statement('authors')
503 503 end
504 504 end
505 505
506 506 def test_fields_for_order_statement_with_blank_format_should_return_default
507 507 with_settings :user_format => '' do
508 508 assert_equal ['users.firstname', 'users.lastname', 'users.id'],
509 509 User.fields_for_order_statement
510 510 end
511 511 end
512 512
513 513 def test_fields_for_order_statement_with_invalid_format_should_return_default
514 514 with_settings :user_format => 'foo' do
515 515 assert_equal ['users.firstname', 'users.lastname', 'users.id'],
516 516 User.fields_for_order_statement
517 517 end
518 518 end
519 519
520 520 test ".try_to_login with good credentials should return the user" do
521 521 user = User.try_to_login("admin", "admin")
522 522 assert_kind_of User, user
523 523 assert_equal "admin", user.login
524 524 end
525 525
526 526 test ".try_to_login with wrong credentials should return nil" do
527 527 assert_nil User.try_to_login("admin", "foo")
528 528 end
529 529
530 530 def test_try_to_login_with_locked_user_should_return_nil
531 531 @jsmith.status = User::STATUS_LOCKED
532 532 @jsmith.save!
533 533
534 534 user = User.try_to_login("jsmith", "jsmith")
535 535 assert_equal nil, user
536 536 end
537 537
538 538 def test_try_to_login_with_locked_user_and_not_active_only_should_return_user
539 539 @jsmith.status = User::STATUS_LOCKED
540 540 @jsmith.save!
541 541
542 542 user = User.try_to_login("jsmith", "jsmith", false)
543 543 assert_equal @jsmith, user
544 544 end
545 545
546 546 test ".try_to_login should fall-back to case-insensitive if user login is not found as-typed" do
547 547 user = User.try_to_login("AdMin", "admin")
548 548 assert_kind_of User, user
549 549 assert_equal "admin", user.login
550 550 end
551 551
552 552 test ".try_to_login should select the exact matching user first" do
553 553 case_sensitive_user = User.generate! do |user|
554 554 user.password = "admin123"
555 555 end
556 556 # bypass validations to make it appear like existing data
557 557 case_sensitive_user.update_attribute(:login, 'ADMIN')
558 558
559 559 user = User.try_to_login("ADMIN", "admin123")
560 560 assert_kind_of User, user
561 561 assert_equal "ADMIN", user.login
562 562 end
563 563
564 564 if ldap_configured?
565 565 context "#try_to_login using LDAP" do
566 566 context "with failed connection to the LDAP server" do
567 567 should "return nil" do
568 568 @auth_source = AuthSourceLdap.find(1)
569 569 AuthSource.any_instance.stubs(:initialize_ldap_con).raises(Net::LDAP::LdapError, 'Cannot connect')
570 570
571 571 assert_equal nil, User.try_to_login('edavis', 'wrong')
572 572 end
573 573 end
574 574
575 575 context "with an unsuccessful authentication" do
576 576 should "return nil" do
577 577 assert_equal nil, User.try_to_login('edavis', 'wrong')
578 578 end
579 579 end
580 580
581 581 context "binding with user's account" do
582 582 setup do
583 583 @auth_source = AuthSourceLdap.find(1)
584 584 @auth_source.account = "uid=$login,ou=Person,dc=redmine,dc=org"
585 585 @auth_source.account_password = ''
586 586 @auth_source.save!
587 587
588 588 @ldap_user = User.new(:mail => 'example1@redmine.org', :firstname => 'LDAP', :lastname => 'user', :auth_source_id => 1)
589 589 @ldap_user.login = 'example1'
590 590 @ldap_user.save!
591 591 end
592 592
593 593 context "with a successful authentication" do
594 594 should "return the user" do
595 595 assert_equal @ldap_user, User.try_to_login('example1', '123456')
596 596 end
597 597 end
598 598
599 599 context "with an unsuccessful authentication" do
600 600 should "return nil" do
601 601 assert_nil User.try_to_login('example1', '11111')
602 602 end
603 603 end
604 604 end
605 605
606 606 context "on the fly registration" do
607 607 setup do
608 608 @auth_source = AuthSourceLdap.find(1)
609 609 @auth_source.update_attribute :onthefly_register, true
610 610 end
611 611
612 612 context "with a successful authentication" do
613 613 should "create a new user account if it doesn't exist" do
614 614 assert_difference('User.count') do
615 615 user = User.try_to_login('edavis', '123456')
616 616 assert !user.admin?
617 617 end
618 618 end
619 619
620 620 should "retrieve existing user" do
621 621 user = User.try_to_login('edavis', '123456')
622 622 user.admin = true
623 623 user.save!
624 624
625 625 assert_no_difference('User.count') do
626 626 user = User.try_to_login('edavis', '123456')
627 627 assert user.admin?
628 628 end
629 629 end
630 630 end
631 631
632 632 context "binding with user's account" do
633 633 setup do
634 634 @auth_source = AuthSourceLdap.find(1)
635 635 @auth_source.account = "uid=$login,ou=Person,dc=redmine,dc=org"
636 636 @auth_source.account_password = ''
637 637 @auth_source.save!
638 638 end
639 639
640 640 context "with a successful authentication" do
641 641 should "create a new user account if it doesn't exist" do
642 642 assert_difference('User.count') do
643 643 user = User.try_to_login('example1', '123456')
644 644 assert_kind_of User, user
645 645 end
646 646 end
647 647 end
648 648
649 649 context "with an unsuccessful authentication" do
650 650 should "return nil" do
651 651 assert_nil User.try_to_login('example1', '11111')
652 652 end
653 653 end
654 654 end
655 655 end
656 656 end
657 657
658 658 else
659 659 puts "Skipping LDAP tests."
660 660 end
661 661
662 662 def test_create_anonymous
663 663 AnonymousUser.delete_all
664 664 anon = User.anonymous
665 665 assert !anon.new_record?
666 666 assert_kind_of AnonymousUser, anon
667 667 end
668 668
669 669 def test_ensure_single_anonymous_user
670 670 AnonymousUser.delete_all
671 671 anon1 = User.anonymous
672 672 assert !anon1.new_record?
673 673 assert_kind_of AnonymousUser, anon1
674 674 anon2 = AnonymousUser.create(
675 675 :lastname => 'Anonymous', :firstname => '',
676 676 :mail => '', :login => '', :status => 0)
677 677 assert_equal 1, anon2.errors.count
678 678 end
679 679
680 680 def test_rss_key
681 681 assert_nil @jsmith.rss_token
682 682 key = @jsmith.rss_key
683 683 assert_equal 40, key.length
684 684
685 685 @jsmith.reload
686 686 assert_equal key, @jsmith.rss_key
687 687 end
688 688
689 689 def test_rss_key_should_not_be_generated_twice
690 690 assert_difference 'Token.count', 1 do
691 691 key1 = @jsmith.rss_key
692 692 key2 = @jsmith.rss_key
693 693 assert_equal key1, key2
694 694 end
695 695 end
696 696
697 697 def test_api_key_should_not_be_generated_twice
698 698 assert_difference 'Token.count', 1 do
699 699 key1 = @jsmith.api_key
700 700 key2 = @jsmith.api_key
701 701 assert_equal key1, key2
702 702 end
703 703 end
704 704
705 705 test "#api_key should generate a new one if the user doesn't have one" do
706 706 user = User.generate!(:api_token => nil)
707 707 assert_nil user.api_token
708 708
709 709 key = user.api_key
710 710 assert_equal 40, key.length
711 711 user.reload
712 712 assert_equal key, user.api_key
713 713 end
714 714
715 715 test "#api_key should return the existing api token value" do
716 716 user = User.generate!
717 717 token = Token.create!(:action => 'api')
718 718 user.api_token = token
719 719 assert user.save
720 720
721 721 assert_equal token.value, user.api_key
722 722 end
723 723
724 724 test "#find_by_api_key should return nil if no matching key is found" do
725 725 assert_nil User.find_by_api_key('zzzzzzzzz')
726 726 end
727 727
728 728 test "#find_by_api_key should return nil if the key is found for an inactive user" do
729 729 user = User.generate!
730 730 user.status = User::STATUS_LOCKED
731 731 token = Token.create!(:action => 'api')
732 732 user.api_token = token
733 733 user.save
734 734
735 735 assert_nil User.find_by_api_key(token.value)
736 736 end
737 737
738 738 test "#find_by_api_key should return the user if the key is found for an active user" do
739 739 user = User.generate!
740 740 token = Token.create!(:action => 'api')
741 741 user.api_token = token
742 742 user.save
743 743
744 744 assert_equal user, User.find_by_api_key(token.value)
745 745 end
746 746
747 747 def test_default_admin_account_changed_should_return_false_if_account_was_not_changed
748 748 user = User.find_by_login("admin")
749 749 user.password = "admin"
750 750 assert user.save(:validate => false)
751 751
752 752 assert_equal false, User.default_admin_account_changed?
753 753 end
754 754
755 755 def test_default_admin_account_changed_should_return_true_if_password_was_changed
756 756 user = User.find_by_login("admin")
757 757 user.password = "newpassword"
758 758 user.save!
759 759
760 760 assert_equal true, User.default_admin_account_changed?
761 761 end
762 762
763 763 def test_default_admin_account_changed_should_return_true_if_account_is_disabled
764 764 user = User.find_by_login("admin")
765 765 user.password = "admin"
766 766 user.status = User::STATUS_LOCKED
767 767 assert user.save(:validate => false)
768 768
769 769 assert_equal true, User.default_admin_account_changed?
770 770 end
771 771
772 772 def test_default_admin_account_changed_should_return_true_if_account_does_not_exist
773 773 user = User.find_by_login("admin")
774 774 user.destroy
775 775
776 776 assert_equal true, User.default_admin_account_changed?
777 777 end
778 778
779 779 def test_membership_with_project_should_return_membership
780 780 project = Project.find(1)
781 781
782 782 membership = @jsmith.membership(project)
783 783 assert_kind_of Member, membership
784 784 assert_equal @jsmith, membership.user
785 785 assert_equal project, membership.project
786 786 end
787 787
788 788 def test_membership_with_project_id_should_return_membership
789 789 project = Project.find(1)
790 790
791 791 membership = @jsmith.membership(1)
792 792 assert_kind_of Member, membership
793 793 assert_equal @jsmith, membership.user
794 794 assert_equal project, membership.project
795 795 end
796 796
797 797 def test_membership_for_non_member_should_return_nil
798 798 project = Project.find(1)
799 799
800 800 user = User.generate!
801 801 membership = user.membership(1)
802 802 assert_nil membership
803 803 end
804 804
805 805 def test_roles_for_project
806 806 # user with a role
807 807 roles = @jsmith.roles_for_project(Project.find(1))
808 808 assert_kind_of Role, roles.first
809 809 assert_equal "Manager", roles.first.name
810 810
811 811 # user with no role
812 812 assert_nil @dlopper.roles_for_project(Project.find(2)).detect {|role| role.member?}
813 813 end
814 814
815 815 def test_projects_by_role_for_user_with_role
816 816 user = User.find(2)
817 817 assert_kind_of Hash, user.projects_by_role
818 818 assert_equal 2, user.projects_by_role.size
819 819 assert_equal [1,5], user.projects_by_role[Role.find(1)].collect(&:id).sort
820 820 assert_equal [2], user.projects_by_role[Role.find(2)].collect(&:id).sort
821 821 end
822 822
823 823 def test_accessing_projects_by_role_with_no_projects_should_return_an_empty_array
824 824 user = User.find(2)
825 825 assert_equal [], user.projects_by_role[Role.find(3)]
826 826 # should not update the hash
827 827 assert_nil user.projects_by_role.values.detect(&:blank?)
828 828 end
829 829
830 830 def test_projects_by_role_for_user_with_no_role
831 831 user = User.generate!
832 832 assert_equal({}, user.projects_by_role)
833 833 end
834 834
835 835 def test_projects_by_role_for_anonymous
836 836 assert_equal({}, User.anonymous.projects_by_role)
837 837 end
838 838
839 839 def test_valid_notification_options
840 840 # without memberships
841 841 assert_equal 5, User.find(7).valid_notification_options.size
842 842 # with memberships
843 843 assert_equal 6, User.find(2).valid_notification_options.size
844 844 end
845 845
846 846 def test_valid_notification_options_class_method
847 847 assert_equal 5, User.valid_notification_options.size
848 848 assert_equal 5, User.valid_notification_options(User.find(7)).size
849 849 assert_equal 6, User.valid_notification_options(User.find(2)).size
850 850 end
851 851
852 852 def test_mail_notification_all
853 853 @jsmith.mail_notification = 'all'
854 854 @jsmith.notified_project_ids = []
855 855 @jsmith.save
856 856 @jsmith.reload
857 857 assert @jsmith.projects.first.recipients.include?(@jsmith.mail)
858 858 end
859 859
860 860 def test_mail_notification_selected
861 861 @jsmith.mail_notification = 'selected'
862 862 @jsmith.notified_project_ids = [1]
863 863 @jsmith.save
864 864 @jsmith.reload
865 865 assert Project.find(1).recipients.include?(@jsmith.mail)
866 866 end
867 867
868 868 def test_mail_notification_only_my_events
869 869 @jsmith.mail_notification = 'only_my_events'
870 870 @jsmith.notified_project_ids = []
871 871 @jsmith.save
872 872 @jsmith.reload
873 873 assert !@jsmith.projects.first.recipients.include?(@jsmith.mail)
874 874 end
875 875
876 876 def test_comments_sorting_preference
877 877 assert !@jsmith.wants_comments_in_reverse_order?
878 878 @jsmith.pref.comments_sorting = 'asc'
879 879 assert !@jsmith.wants_comments_in_reverse_order?
880 880 @jsmith.pref.comments_sorting = 'desc'
881 881 assert @jsmith.wants_comments_in_reverse_order?
882 882 end
883 883
884 884 def test_find_by_mail_should_be_case_insensitive
885 885 u = User.find_by_mail('JSmith@somenet.foo')
886 886 assert_not_nil u
887 887 assert_equal 'jsmith@somenet.foo', u.mail
888 888 end
889 889
890 890 def test_random_password
891 891 u = User.new
892 892 u.random_password
893 893 assert !u.password.blank?
894 894 assert !u.password_confirmation.blank?
895 895 end
896 896
897 897 test "#change_password_allowed? should be allowed if no auth source is set" do
898 898 user = User.generate!
899 899 assert user.change_password_allowed?
900 900 end
901 901
902 902 test "#change_password_allowed? should delegate to the auth source" do
903 903 user = User.generate!
904 904
905 905 allowed_auth_source = AuthSource.generate!
906 906 def allowed_auth_source.allow_password_changes?; true; end
907 907
908 908 denied_auth_source = AuthSource.generate!
909 909 def denied_auth_source.allow_password_changes?; false; end
910 910
911 911 assert user.change_password_allowed?
912 912
913 913 user.auth_source = allowed_auth_source
914 914 assert user.change_password_allowed?, "User not allowed to change password, though auth source does"
915 915
916 916 user.auth_source = denied_auth_source
917 917 assert !user.change_password_allowed?, "User allowed to change password, though auth source does not"
918 918 end
919 919
920 920 def test_own_account_deletable_should_be_true_with_unsubscrive_enabled
921 921 with_settings :unsubscribe => '1' do
922 922 assert_equal true, User.find(2).own_account_deletable?
923 923 end
924 924 end
925 925
926 926 def test_own_account_deletable_should_be_false_with_unsubscrive_disabled
927 927 with_settings :unsubscribe => '0' do
928 928 assert_equal false, User.find(2).own_account_deletable?
929 929 end
930 930 end
931 931
932 932 def test_own_account_deletable_should_be_false_for_a_single_admin
933 933 User.delete_all(["admin = ? AND id <> ?", true, 1])
934 934
935 935 with_settings :unsubscribe => '1' do
936 936 assert_equal false, User.find(1).own_account_deletable?
937 937 end
938 938 end
939 939
940 940 def test_own_account_deletable_should_be_true_for_an_admin_if_other_admin_exists
941 941 User.generate! do |user|
942 942 user.admin = true
943 943 end
944 944
945 945 with_settings :unsubscribe => '1' do
946 946 assert_equal true, User.find(1).own_account_deletable?
947 947 end
948 948 end
949 949
950 950 context "#allowed_to?" do
951 951 context "with a unique project" do
952 952 should "return false if project is archived" do
953 953 project = Project.find(1)
954 954 Project.any_instance.stubs(:status).returns(Project::STATUS_ARCHIVED)
955 955 assert_equal false, @admin.allowed_to?(:view_issues, Project.find(1))
956 956 end
957 957
958 958 should "return false for write action if project is closed" do
959 959 project = Project.find(1)
960 960 Project.any_instance.stubs(:status).returns(Project::STATUS_CLOSED)
961 961 assert_equal false, @admin.allowed_to?(:edit_project, Project.find(1))
962 962 end
963 963
964 964 should "return true for read action if project is closed" do
965 965 project = Project.find(1)
966 966 Project.any_instance.stubs(:status).returns(Project::STATUS_CLOSED)
967 967 assert_equal true, @admin.allowed_to?(:view_project, Project.find(1))
968 968 end
969 969
970 970 should "return false if related module is disabled" do
971 971 project = Project.find(1)
972 972 project.enabled_module_names = ["issue_tracking"]
973 973 assert_equal true, @admin.allowed_to?(:add_issues, project)
974 974 assert_equal false, @admin.allowed_to?(:view_wiki_pages, project)
975 975 end
976 976
977 977 should "authorize nearly everything for admin users" do
978 978 project = Project.find(1)
979 979 assert ! @admin.member_of?(project)
980 980 %w(edit_issues delete_issues manage_news add_documents manage_wiki).each do |p|
981 981 assert_equal true, @admin.allowed_to?(p.to_sym, project)
982 982 end
983 983 end
984 984
985 985 should "authorize normal users depending on their roles" do
986 986 project = Project.find(1)
987 987 assert_equal true, @jsmith.allowed_to?(:delete_messages, project) #Manager
988 988 assert_equal false, @dlopper.allowed_to?(:delete_messages, project) #Developper
989 989 end
990 990 end
991 991
992 992 context "with multiple projects" do
993 993 should "return false if array is empty" do
994 994 assert_equal false, @admin.allowed_to?(:view_project, [])
995 995 end
996 996
997 997 should "return true only if user has permission on all these projects" do
998 998 assert_equal true, @admin.allowed_to?(:view_project, Project.all)
999 999 assert_equal false, @dlopper.allowed_to?(:view_project, Project.all) #cannot see Project(2)
1000 1000 assert_equal true, @jsmith.allowed_to?(:edit_issues, @jsmith.projects) #Manager or Developer everywhere
1001 1001 assert_equal false, @jsmith.allowed_to?(:delete_issue_watchers, @jsmith.projects) #Dev cannot delete_issue_watchers
1002 1002 end
1003 1003
1004 1004 should "behave correctly with arrays of 1 project" do
1005 1005 assert_equal false, User.anonymous.allowed_to?(:delete_issues, [Project.first])
1006 1006 end
1007 1007 end
1008 1008
1009 1009 context "with options[:global]" do
1010 1010 should "authorize if user has at least one role that has this permission" do
1011 1011 @dlopper2 = User.find(5) #only Developper on a project, not Manager anywhere
1012 1012 @anonymous = User.find(6)
1013 1013 assert_equal true, @jsmith.allowed_to?(:delete_issue_watchers, nil, :global => true)
1014 1014 assert_equal false, @dlopper2.allowed_to?(:delete_issue_watchers, nil, :global => true)
1015 1015 assert_equal true, @dlopper2.allowed_to?(:add_issues, nil, :global => true)
1016 1016 assert_equal false, @anonymous.allowed_to?(:add_issues, nil, :global => true)
1017 1017 assert_equal true, @anonymous.allowed_to?(:view_issues, nil, :global => true)
1018 1018 end
1019 1019 end
1020 1020 end
1021 1021
1022 1022 context "User#notify_about?" do
1023 1023 context "Issues" do
1024 1024 setup do
1025 1025 @project = Project.find(1)
1026 1026 @author = User.generate!
1027 1027 @assignee = User.generate!
1028 1028 @issue = Issue.generate!(:project => @project, :assigned_to => @assignee, :author => @author)
1029 1029 end
1030 1030
1031 1031 should "be true for a user with :all" do
1032 1032 @author.update_attribute(:mail_notification, 'all')
1033 1033 assert @author.notify_about?(@issue)
1034 1034 end
1035 1035
1036 1036 should "be false for a user with :none" do
1037 1037 @author.update_attribute(:mail_notification, 'none')
1038 1038 assert ! @author.notify_about?(@issue)
1039 1039 end
1040 1040
1041 1041 should "be false for a user with :only_my_events and isn't an author, creator, or assignee" do
1042 1042 @user = User.generate!(:mail_notification => 'only_my_events')
1043 1043 Member.create!(:user => @user, :project => @project, :role_ids => [1])
1044 1044 assert ! @user.notify_about?(@issue)
1045 1045 end
1046 1046
1047 1047 should "be true for a user with :only_my_events and is the author" do
1048 1048 @author.update_attribute(:mail_notification, 'only_my_events')
1049 1049 assert @author.notify_about?(@issue)
1050 1050 end
1051 1051
1052 1052 should "be true for a user with :only_my_events and is the assignee" do
1053 1053 @assignee.update_attribute(:mail_notification, 'only_my_events')
1054 1054 assert @assignee.notify_about?(@issue)
1055 1055 end
1056 1056
1057 1057 should "be true for a user with :only_assigned and is the assignee" do
1058 1058 @assignee.update_attribute(:mail_notification, 'only_assigned')
1059 1059 assert @assignee.notify_about?(@issue)
1060 1060 end
1061 1061
1062 1062 should "be false for a user with :only_assigned and is not the assignee" do
1063 1063 @author.update_attribute(:mail_notification, 'only_assigned')
1064 1064 assert ! @author.notify_about?(@issue)
1065 1065 end
1066 1066
1067 1067 should "be true for a user with :only_owner and is the author" do
1068 1068 @author.update_attribute(:mail_notification, 'only_owner')
1069 1069 assert @author.notify_about?(@issue)
1070 1070 end
1071 1071
1072 1072 should "be false for a user with :only_owner and is not the author" do
1073 1073 @assignee.update_attribute(:mail_notification, 'only_owner')
1074 1074 assert ! @assignee.notify_about?(@issue)
1075 1075 end
1076 1076
1077 1077 should "be true for a user with :selected and is the author" do
1078 1078 @author.update_attribute(:mail_notification, 'selected')
1079 1079 assert @author.notify_about?(@issue)
1080 1080 end
1081 1081
1082 1082 should "be true for a user with :selected and is the assignee" do
1083 1083 @assignee.update_attribute(:mail_notification, 'selected')
1084 1084 assert @assignee.notify_about?(@issue)
1085 1085 end
1086 1086
1087 1087 should "be false for a user with :selected and is not the author or assignee" do
1088 1088 @user = User.generate!(:mail_notification => 'selected')
1089 1089 Member.create!(:user => @user, :project => @project, :role_ids => [1])
1090 1090 assert ! @user.notify_about?(@issue)
1091 1091 end
1092 1092 end
1093 1093 end
1094 1094
1095 1095 def test_notify_about_news
1096 1096 user = User.generate!
1097 1097 news = News.new
1098 1098
1099 1099 User::MAIL_NOTIFICATION_OPTIONS.map(&:first).each do |option|
1100 1100 user.mail_notification = option
1101 1101 assert_equal (option != 'none'), user.notify_about?(news)
1102 1102 end
1103 1103 end
1104 1104
1105 1105 def test_salt_unsalted_passwords
1106 1106 # Restore a user with an unsalted password
1107 1107 user = User.find(1)
1108 1108 user.salt = nil
1109 1109 user.hashed_password = User.hash_password("unsalted")
1110 1110 user.save!
1111 1111
1112 1112 User.salt_unsalted_passwords!
1113 1113
1114 1114 user.reload
1115 1115 # Salt added
1116 1116 assert !user.salt.blank?
1117 1117 # Password still valid
1118 1118 assert user.check_password?("unsalted")
1119 1119 assert_equal user, User.try_to_login(user.login, "unsalted")
1120 1120 end
1121 1121
1122 1122 if Object.const_defined?(:OpenID)
1123 1123 def test_setting_identity_url
1124 1124 normalized_open_id_url = 'http://example.com/'
1125 1125 u = User.new( :identity_url => 'http://example.com/' )
1126 1126 assert_equal normalized_open_id_url, u.identity_url
1127 1127 end
1128 1128
1129 1129 def test_setting_identity_url_without_trailing_slash
1130 1130 normalized_open_id_url = 'http://example.com/'
1131 1131 u = User.new( :identity_url => 'http://example.com' )
1132 1132 assert_equal normalized_open_id_url, u.identity_url
1133 1133 end
1134 1134
1135 1135 def test_setting_identity_url_without_protocol
1136 1136 normalized_open_id_url = 'http://example.com/'
1137 1137 u = User.new( :identity_url => 'example.com' )
1138 1138 assert_equal normalized_open_id_url, u.identity_url
1139 1139 end
1140 1140
1141 1141 def test_setting_blank_identity_url
1142 1142 u = User.new( :identity_url => 'example.com' )
1143 1143 u.identity_url = ''
1144 1144 assert u.identity_url.blank?
1145 1145 end
1146 1146
1147 1147 def test_setting_invalid_identity_url
1148 1148 u = User.new( :identity_url => 'this is not an openid url' )
1149 1149 assert u.identity_url.blank?
1150 1150 end
1151 1151 else
1152 1152 puts "Skipping openid tests."
1153 1153 end
1154 1154 end
General Comments 0
You need to be logged in to leave comments. Login now