##// END OF EJS Templates
jro_apps » redmine
RSS
Rails3: test: replace deprecated Errors#on to Errors#[] and join with to_s at test/unit/user_test.rb...
Toshi MARUYAMA -
r8017:8e5242ef6351
parent child
Show More
Side by Side Unified
Context file:
r8017:8e5242ef6351 Loading diff...:
Show file before | Show file after | Hide comments
@@ -1,879 +1,882
1 1 # Redmine - project management software
2 2 # Copyright (C) 2006-2011 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 :workflows
30 30
31 31 def setup
32 32 @admin = User.find(1)
33 33 @jsmith = User.find(2)
34 34 @dlopper = User.find(3)
35 35 end
36 36
37 37 test 'object_daddy creation' do
38 38 User.generate_with_protected!(:firstname => 'Testing connection')
39 39 User.generate_with_protected!(:firstname => 'Testing connection')
40 40 assert_equal 2, User.count(:all, :conditions => {:firstname => 'Testing connection'})
41 41 end
42 42
43 43 def test_truth
44 44 assert_kind_of User, @jsmith
45 45 end
46 46
47 47 def test_mail_should_be_stripped
48 48 u = User.new
49 49 u.mail = " foo@bar.com "
50 50 assert_equal "foo@bar.com", u.mail
51 51 end
52 52
53 53 def test_mail_validation
54 54 u = User.new
55 55 u.mail = ''
56 56 assert !u.valid?
57 assert_equal I18n.translate('activerecord.errors.messages.blank'), u.errors.on(:mail)
57 assert_equal I18n.translate('activerecord.errors.messages.blank'),
58 u.errors[:mail].to_s
58 59 end
59 60
60 61 def test_create
61 62 user = User.new(:firstname => "new", :lastname => "user", :mail => "newuser@somenet.foo")
62 63
63 64 user.login = "jsmith"
64 65 user.password, user.password_confirmation = "password", "password"
65 66 # login uniqueness
66 67 assert !user.save
67 68 assert_equal 1, user.errors.count
68 69
69 70 user.login = "newuser"
70 71 user.password, user.password_confirmation = "passwd", "password"
71 72 # password confirmation
72 73 assert !user.save
73 74 assert_equal 1, user.errors.count
74 75
75 76 user.password, user.password_confirmation = "password", "password"
76 77 assert user.save
77 78 end
78 79
79 80 context "User#before_create" do
80 81 should "set the mail_notification to the default Setting" do
81 82 @user1 = User.generate_with_protected!
82 83 assert_equal 'only_my_events', @user1.mail_notification
83 84
84 85 with_settings :default_notification_option => 'all' do
85 86 @user2 = User.generate_with_protected!
86 87 assert_equal 'all', @user2.mail_notification
87 88 end
88 89 end
89 90 end
90 91
91 92 context "User.login" do
92 93 should "be case-insensitive." do
93 94 u = User.new(:firstname => "new", :lastname => "user", :mail => "newuser@somenet.foo")
94 95 u.login = 'newuser'
95 96 u.password, u.password_confirmation = "password", "password"
96 97 assert u.save
97 98
98 99 u = User.new(:firstname => "Similar", :lastname => "User", :mail => "similaruser@somenet.foo")
99 100 u.login = 'NewUser'
100 101 u.password, u.password_confirmation = "password", "password"
101 102 assert !u.save
102 assert_equal I18n.translate('activerecord.errors.messages.taken'), u.errors.on(:login)
103 assert_equal I18n.translate('activerecord.errors.messages.taken'),
104 u.errors[:login].to_s
103 105 end
104 106 end
105 107
106 108 def test_mail_uniqueness_should_not_be_case_sensitive
107 109 u = User.new(:firstname => "new", :lastname => "user", :mail => "newuser@somenet.foo")
108 110 u.login = 'newuser1'
109 111 u.password, u.password_confirmation = "password", "password"
110 112 assert u.save
111 113
112 114 u = User.new(:firstname => "new", :lastname => "user", :mail => "newUser@Somenet.foo")
113 115 u.login = 'newuser2'
114 116 u.password, u.password_confirmation = "password", "password"
115 117 assert !u.save
116 assert_equal I18n.translate('activerecord.errors.messages.taken'), u.errors.on(:mail)
118 assert_equal I18n.translate('activerecord.errors.messages.taken'),
119 u.errors[:mail].to_s
117 120 end
118 121
119 122 def test_update
120 123 assert_equal "admin", @admin.login
121 124 @admin.login = "john"
122 125 assert @admin.save, @admin.errors.full_messages.join("; ")
123 126 @admin.reload
124 127 assert_equal "john", @admin.login
125 128 end
126 129
127 130 def test_destroy_should_delete_members_and_roles
128 131 members = Member.find_all_by_user_id(2)
129 132 ms = members.size
130 133 rs = members.collect(&:roles).flatten.size
131 134
132 135 assert_difference 'Member.count', - ms do
133 136 assert_difference 'MemberRole.count', - rs do
134 137 User.find(2).destroy
135 138 end
136 139 end
137 140
138 141 assert_nil User.find_by_id(2)
139 142 assert Member.find_all_by_user_id(2).empty?
140 143 end
141 144
142 145 def test_destroy_should_update_attachments
143 146 attachment = Attachment.create!(:container => Project.find(1),
144 147 :file => uploaded_test_file("testfile.txt", "text/plain"),
145 148 :author_id => 2)
146 149
147 150 User.find(2).destroy
148 151 assert_nil User.find_by_id(2)
149 152 assert_equal User.anonymous, attachment.reload.author
150 153 end
151 154
152 155 def test_destroy_should_update_comments
153 156 comment = Comment.create!(
154 157 :commented => News.create!(:project_id => 1, :author_id => 1, :title => 'foo', :description => 'foo'),
155 158 :author => User.find(2),
156 159 :comments => 'foo'
157 160 )
158 161
159 162 User.find(2).destroy
160 163 assert_nil User.find_by_id(2)
161 164 assert_equal User.anonymous, comment.reload.author
162 165 end
163 166
164 167 def test_destroy_should_update_issues
165 168 issue = Issue.create!(:project_id => 1, :author_id => 2, :tracker_id => 1, :subject => 'foo')
166 169
167 170 User.find(2).destroy
168 171 assert_nil User.find_by_id(2)
169 172 assert_equal User.anonymous, issue.reload.author
170 173 end
171 174
172 175 def test_destroy_should_unassign_issues
173 176 issue = Issue.create!(:project_id => 1, :author_id => 1, :tracker_id => 1, :subject => 'foo', :assigned_to_id => 2)
174 177
175 178 User.find(2).destroy
176 179 assert_nil User.find_by_id(2)
177 180 assert_nil issue.reload.assigned_to
178 181 end
179 182
180 183 def test_destroy_should_update_journals
181 184 issue = Issue.create!(:project_id => 1, :author_id => 2, :tracker_id => 1, :subject => 'foo')
182 185 issue.init_journal(User.find(2), "update")
183 186 issue.save!
184 187
185 188 User.find(2).destroy
186 189 assert_nil User.find_by_id(2)
187 190 assert_equal User.anonymous, issue.journals.first.reload.user
188 191 end
189 192
190 193 def test_destroy_should_update_journal_details_old_value
191 194 issue = Issue.create!(:project_id => 1, :author_id => 1, :tracker_id => 1, :subject => 'foo', :assigned_to_id => 2)
192 195 issue.init_journal(User.find(1), "update")
193 196 issue.assigned_to_id = nil
194 197 assert_difference 'JournalDetail.count' do
195 198 issue.save!
196 199 end
197 200 journal_detail = JournalDetail.first(:order => 'id DESC')
198 201 assert_equal '2', journal_detail.old_value
199 202
200 203 User.find(2).destroy
201 204 assert_nil User.find_by_id(2)
202 205 assert_equal User.anonymous.id.to_s, journal_detail.reload.old_value
203 206 end
204 207
205 208 def test_destroy_should_update_journal_details_value
206 209 issue = Issue.create!(:project_id => 1, :author_id => 1, :tracker_id => 1, :subject => 'foo')
207 210 issue.init_journal(User.find(1), "update")
208 211 issue.assigned_to_id = 2
209 212 assert_difference 'JournalDetail.count' do
210 213 issue.save!
211 214 end
212 215 journal_detail = JournalDetail.first(:order => 'id DESC')
213 216 assert_equal '2', journal_detail.value
214 217
215 218 User.find(2).destroy
216 219 assert_nil User.find_by_id(2)
217 220 assert_equal User.anonymous.id.to_s, journal_detail.reload.value
218 221 end
219 222
220 223 def test_destroy_should_update_messages
221 224 board = Board.create!(:project_id => 1, :name => 'Board', :description => 'Board')
222 225 message = Message.create!(:board_id => board.id, :author_id => 2, :subject => 'foo', :content => 'foo')
223 226
224 227 User.find(2).destroy
225 228 assert_nil User.find_by_id(2)
226 229 assert_equal User.anonymous, message.reload.author
227 230 end
228 231
229 232 def test_destroy_should_update_news
230 233 news = News.create!(:project_id => 1, :author_id => 2, :title => 'foo', :description => 'foo')
231 234
232 235 User.find(2).destroy
233 236 assert_nil User.find_by_id(2)
234 237 assert_equal User.anonymous, news.reload.author
235 238 end
236 239
237 240 def test_destroy_should_delete_private_queries
238 241 query = Query.new(:name => 'foo', :is_public => false)
239 242 query.project_id = 1
240 243 query.user_id = 2
241 244 query.save!
242 245
243 246 User.find(2).destroy
244 247 assert_nil User.find_by_id(2)
245 248 assert_nil Query.find_by_id(query.id)
246 249 end
247 250
248 251 def test_destroy_should_update_public_queries
249 252 query = Query.new(:name => 'foo', :is_public => true)
250 253 query.project_id = 1
251 254 query.user_id = 2
252 255 query.save!
253 256
254 257 User.find(2).destroy
255 258 assert_nil User.find_by_id(2)
256 259 assert_equal User.anonymous, query.reload.user
257 260 end
258 261
259 262 def test_destroy_should_update_time_entries
260 263 entry = TimeEntry.new(:hours => '2', :spent_on => Date.today, :activity => TimeEntryActivity.create!(:name => 'foo'))
261 264 entry.project_id = 1
262 265 entry.user_id = 2
263 266 entry.save!
264 267
265 268 User.find(2).destroy
266 269 assert_nil User.find_by_id(2)
267 270 assert_equal User.anonymous, entry.reload.user
268 271 end
269 272
270 273 def test_destroy_should_delete_tokens
271 274 token = Token.create!(:user_id => 2, :value => 'foo')
272 275
273 276 User.find(2).destroy
274 277 assert_nil User.find_by_id(2)
275 278 assert_nil Token.find_by_id(token.id)
276 279 end
277 280
278 281 def test_destroy_should_delete_watchers
279 282 issue = Issue.create!(:project_id => 1, :author_id => 1, :tracker_id => 1, :subject => 'foo')
280 283 watcher = Watcher.create!(:user_id => 2, :watchable => issue)
281 284
282 285 User.find(2).destroy
283 286 assert_nil User.find_by_id(2)
284 287 assert_nil Watcher.find_by_id(watcher.id)
285 288 end
286 289
287 290 def test_destroy_should_update_wiki_contents
288 291 wiki_content = WikiContent.create!(
289 292 :text => 'foo',
290 293 :author_id => 2,
291 294 :page => WikiPage.create!(:title => 'Foo', :wiki => Wiki.create!(:project_id => 1, :start_page => 'Start'))
292 295 )
293 296 wiki_content.text = 'bar'
294 297 assert_difference 'WikiContent::Version.count' do
295 298 wiki_content.save!
296 299 end
297 300
298 301 User.find(2).destroy
299 302 assert_nil User.find_by_id(2)
300 303 assert_equal User.anonymous, wiki_content.reload.author
301 304 wiki_content.versions.each do |version|
302 305 assert_equal User.anonymous, version.reload.author
303 306 end
304 307 end
305 308
306 309 def test_destroy_should_nullify_issue_categories
307 310 category = IssueCategory.create!(:project_id => 1, :assigned_to_id => 2, :name => 'foo')
308 311
309 312 User.find(2).destroy
310 313 assert_nil User.find_by_id(2)
311 314 assert_nil category.reload.assigned_to_id
312 315 end
313 316
314 317 def test_destroy_should_nullify_changesets
315 318 changeset = Changeset.create!(
316 319 :repository => Repository::Subversion.create!(
317 320 :project_id => 1,
318 321 :url => 'file:///var/svn'
319 322 ),
320 323 :revision => '12',
321 324 :committed_on => Time.now,
322 325 :committer => 'jsmith'
323 326 )
324 327 assert_equal 2, changeset.user_id
325 328
326 329 User.find(2).destroy
327 330 assert_nil User.find_by_id(2)
328 331 assert_nil changeset.reload.user_id
329 332 end
330 333
331 334 def test_anonymous_user_should_not_be_destroyable
332 335 assert_no_difference 'User.count' do
333 336 assert_equal false, User.anonymous.destroy
334 337 end
335 338 end
336 339
337 340 def test_validate_login_presence
338 341 @admin.login = ""
339 342 assert !@admin.save
340 343 assert_equal 1, @admin.errors.count
341 344 end
342 345
343 346 def test_validate_mail_notification_inclusion
344 347 u = User.new
345 348 u.mail_notification = 'foo'
346 349 u.save
347 350 assert_not_nil u.errors[:mail_notification]
348 351 end
349 352
350 353 context "User#try_to_login" do
351 354 should "fall-back to case-insensitive if user login is not found as-typed." do
352 355 user = User.try_to_login("AdMin", "admin")
353 356 assert_kind_of User, user
354 357 assert_equal "admin", user.login
355 358 end
356 359
357 360 should "select the exact matching user first" do
358 361 case_sensitive_user = User.generate_with_protected!(
359 362 :login => 'changed', :password => 'admin',
360 363 :password_confirmation => 'admin')
361 364 # bypass validations to make it appear like existing data
362 365 case_sensitive_user.update_attribute(:login, 'ADMIN')
363 366
364 367 user = User.try_to_login("ADMIN", "admin")
365 368 assert_kind_of User, user
366 369 assert_equal "ADMIN", user.login
367 370
368 371 end
369 372 end
370 373
371 374 def test_password
372 375 user = User.try_to_login("admin", "admin")
373 376 assert_kind_of User, user
374 377 assert_equal "admin", user.login
375 378 user.password = "hello"
376 379 assert user.save
377 380
378 381 user = User.try_to_login("admin", "hello")
379 382 assert_kind_of User, user
380 383 assert_equal "admin", user.login
381 384 end
382 385
383 386 def test_validate_password_length
384 387 with_settings :password_min_length => '100' do
385 388 user = User.new(:firstname => "new100", :lastname => "user100", :mail => "newuser100@somenet.foo")
386 389 user.login = "newuser100"
387 390 user.password, user.password_confirmation = "password100", "password100"
388 391 assert !user.save
389 392 assert_equal 1, user.errors.count
390 393 end
391 394 end
392 395
393 396 def test_name_format
394 397 assert_equal 'Smith, John', @jsmith.name(:lastname_coma_firstname)
395 398 with_settings :user_format => :firstname_lastname do
396 399 assert_equal 'John Smith', @jsmith.reload.name
397 400 end
398 401 with_settings :user_format => :username do
399 402 assert_equal 'jsmith', @jsmith.reload.name
400 403 end
401 404 end
402 405
403 406 def test_fields_for_order_statement_should_return_fields_according_user_format_setting
404 407 with_settings :user_format => 'lastname_coma_firstname' do
405 408 assert_equal ['users.lastname', 'users.firstname', 'users.id'], User.fields_for_order_statement
406 409 end
407 410 end
408 411
409 412 def test_fields_for_order_statement_width_table_name_should_prepend_table_name
410 413 with_settings :user_format => 'lastname_firstname' do
411 414 assert_equal ['authors.lastname', 'authors.firstname', 'authors.id'], User.fields_for_order_statement('authors')
412 415 end
413 416 end
414 417
415 418 def test_fields_for_order_statement_with_blank_format_should_return_default
416 419 with_settings :user_format => '' do
417 420 assert_equal ['users.firstname', 'users.lastname', 'users.id'], User.fields_for_order_statement
418 421 end
419 422 end
420 423
421 424 def test_fields_for_order_statement_with_invalid_format_should_return_default
422 425 with_settings :user_format => 'foo' do
423 426 assert_equal ['users.firstname', 'users.lastname', 'users.id'], User.fields_for_order_statement
424 427 end
425 428 end
426 429
427 430 def test_lock
428 431 user = User.try_to_login("jsmith", "jsmith")
429 432 assert_equal @jsmith, user
430 433
431 434 @jsmith.status = User::STATUS_LOCKED
432 435 assert @jsmith.save
433 436
434 437 user = User.try_to_login("jsmith", "jsmith")
435 438 assert_equal nil, user
436 439 end
437 440
438 441 context ".try_to_login" do
439 442 context "with good credentials" do
440 443 should "return the user" do
441 444 user = User.try_to_login("admin", "admin")
442 445 assert_kind_of User, user
443 446 assert_equal "admin", user.login
444 447 end
445 448 end
446 449
447 450 context "with wrong credentials" do
448 451 should "return nil" do
449 452 assert_nil User.try_to_login("admin", "foo")
450 453 end
451 454 end
452 455 end
453 456
454 457 if ldap_configured?
455 458 context "#try_to_login using LDAP" do
456 459 context "with failed connection to the LDAP server" do
457 460 should "return nil" do
458 461 @auth_source = AuthSourceLdap.find(1)
459 462 AuthSource.any_instance.stubs(:initialize_ldap_con).raises(Net::LDAP::LdapError, 'Cannot connect')
460 463
461 464 assert_equal nil, User.try_to_login('edavis', 'wrong')
462 465 end
463 466 end
464 467
465 468 context "with an unsuccessful authentication" do
466 469 should "return nil" do
467 470 assert_equal nil, User.try_to_login('edavis', 'wrong')
468 471 end
469 472 end
470 473
471 474 context "on the fly registration" do
472 475 setup do
473 476 @auth_source = AuthSourceLdap.find(1)
474 477 end
475 478
476 479 context "with a successful authentication" do
477 480 should "create a new user account if it doesn't exist" do
478 481 assert_difference('User.count') do
479 482 user = User.try_to_login('edavis', '123456')
480 483 assert !user.admin?
481 484 end
482 485 end
483 486
484 487 should "retrieve existing user" do
485 488 user = User.try_to_login('edavis', '123456')
486 489 user.admin = true
487 490 user.save!
488 491
489 492 assert_no_difference('User.count') do
490 493 user = User.try_to_login('edavis', '123456')
491 494 assert user.admin?
492 495 end
493 496 end
494 497 end
495 498 end
496 499 end
497 500
498 501 else
499 502 puts "Skipping LDAP tests."
500 503 end
501 504
502 505 def test_create_anonymous
503 506 AnonymousUser.delete_all
504 507 anon = User.anonymous
505 508 assert !anon.new_record?
506 509 assert_kind_of AnonymousUser, anon
507 510 end
508 511
509 512 def test_ensure_single_anonymous_user
510 513 AnonymousUser.delete_all
511 514 anon1 = User.anonymous
512 515 assert !anon1.new_record?
513 516 assert_kind_of AnonymousUser, anon1
514 517 anon2 = AnonymousUser.create(
515 518 :lastname => 'Anonymous', :firstname => '',
516 519 :mail => '', :login => '', :status => 0)
517 520 assert_equal 1, anon2.errors.count
518 521 end
519 522
520 523 should_have_one :rss_token
521 524
522 525 def test_rss_key
523 526 assert_nil @jsmith.rss_token
524 527 key = @jsmith.rss_key
525 528 assert_equal 40, key.length
526 529
527 530 @jsmith.reload
528 531 assert_equal key, @jsmith.rss_key
529 532 end
530 533
531 534
532 535 should_have_one :api_token
533 536
534 537 context "User#api_key" do
535 538 should "generate a new one if the user doesn't have one" do
536 539 user = User.generate_with_protected!(:api_token => nil)
537 540 assert_nil user.api_token
538 541
539 542 key = user.api_key
540 543 assert_equal 40, key.length
541 544 user.reload
542 545 assert_equal key, user.api_key
543 546 end
544 547
545 548 should "return the existing api token value" do
546 549 user = User.generate_with_protected!
547 550 token = Token.generate!(:action => 'api')
548 551 user.api_token = token
549 552 assert user.save
550 553
551 554 assert_equal token.value, user.api_key
552 555 end
553 556 end
554 557
555 558 context "User#find_by_api_key" do
556 559 should "return nil if no matching key is found" do
557 560 assert_nil User.find_by_api_key('zzzzzzzzz')
558 561 end
559 562
560 563 should "return nil if the key is found for an inactive user" do
561 564 user = User.generate_with_protected!(:status => User::STATUS_LOCKED)
562 565 token = Token.generate!(:action => 'api')
563 566 user.api_token = token
564 567 user.save
565 568
566 569 assert_nil User.find_by_api_key(token.value)
567 570 end
568 571
569 572 should "return the user if the key is found for an active user" do
570 573 user = User.generate_with_protected!(:status => User::STATUS_ACTIVE)
571 574 token = Token.generate!(:action => 'api')
572 575 user.api_token = token
573 576 user.save
574 577
575 578 assert_equal user, User.find_by_api_key(token.value)
576 579 end
577 580 end
578 581
579 582 def test_roles_for_project
580 583 # user with a role
581 584 roles = @jsmith.roles_for_project(Project.find(1))
582 585 assert_kind_of Role, roles.first
583 586 assert_equal "Manager", roles.first.name
584 587
585 588 # user with no role
586 589 assert_nil @dlopper.roles_for_project(Project.find(2)).detect {|role| role.member?}
587 590 end
588 591
589 592 def test_projects_by_role_for_user_with_role
590 593 user = User.find(2)
591 594 assert_kind_of Hash, user.projects_by_role
592 595 assert_equal 2, user.projects_by_role.size
593 596 assert_equal [1,5], user.projects_by_role[Role.find(1)].collect(&:id).sort
594 597 assert_equal [2], user.projects_by_role[Role.find(2)].collect(&:id).sort
595 598 end
596 599
597 600 def test_projects_by_role_for_user_with_no_role
598 601 user = User.generate!
599 602 assert_equal({}, user.projects_by_role)
600 603 end
601 604
602 605 def test_projects_by_role_for_anonymous
603 606 assert_equal({}, User.anonymous.projects_by_role)
604 607 end
605 608
606 609 def test_valid_notification_options
607 610 # without memberships
608 611 assert_equal 5, User.find(7).valid_notification_options.size
609 612 # with memberships
610 613 assert_equal 6, User.find(2).valid_notification_options.size
611 614 end
612 615
613 616 def test_valid_notification_options_class_method
614 617 assert_equal 5, User.valid_notification_options.size
615 618 assert_equal 5, User.valid_notification_options(User.find(7)).size
616 619 assert_equal 6, User.valid_notification_options(User.find(2)).size
617 620 end
618 621
619 622 def test_mail_notification_all
620 623 @jsmith.mail_notification = 'all'
621 624 @jsmith.notified_project_ids = []
622 625 @jsmith.save
623 626 @jsmith.reload
624 627 assert @jsmith.projects.first.recipients.include?(@jsmith.mail)
625 628 end
626 629
627 630 def test_mail_notification_selected
628 631 @jsmith.mail_notification = 'selected'
629 632 @jsmith.notified_project_ids = [1]
630 633 @jsmith.save
631 634 @jsmith.reload
632 635 assert Project.find(1).recipients.include?(@jsmith.mail)
633 636 end
634 637
635 638 def test_mail_notification_only_my_events
636 639 @jsmith.mail_notification = 'only_my_events'
637 640 @jsmith.notified_project_ids = []
638 641 @jsmith.save
639 642 @jsmith.reload
640 643 assert !@jsmith.projects.first.recipients.include?(@jsmith.mail)
641 644 end
642 645
643 646 def test_comments_sorting_preference
644 647 assert !@jsmith.wants_comments_in_reverse_order?
645 648 @jsmith.pref.comments_sorting = 'asc'
646 649 assert !@jsmith.wants_comments_in_reverse_order?
647 650 @jsmith.pref.comments_sorting = 'desc'
648 651 assert @jsmith.wants_comments_in_reverse_order?
649 652 end
650 653
651 654 def test_find_by_mail_should_be_case_insensitive
652 655 u = User.find_by_mail('JSmith@somenet.foo')
653 656 assert_not_nil u
654 657 assert_equal 'jsmith@somenet.foo', u.mail
655 658 end
656 659
657 660 def test_random_password
658 661 u = User.new
659 662 u.random_password
660 663 assert !u.password.blank?
661 664 assert !u.password_confirmation.blank?
662 665 end
663 666
664 667 context "#change_password_allowed?" do
665 668 should "be allowed if no auth source is set" do
666 669 user = User.generate_with_protected!
667 670 assert user.change_password_allowed?
668 671 end
669 672
670 673 should "delegate to the auth source" do
671 674 user = User.generate_with_protected!
672 675
673 676 allowed_auth_source = AuthSource.generate!
674 677 def allowed_auth_source.allow_password_changes?; true; end
675 678
676 679 denied_auth_source = AuthSource.generate!
677 680 def denied_auth_source.allow_password_changes?; false; end
678 681
679 682 assert user.change_password_allowed?
680 683
681 684 user.auth_source = allowed_auth_source
682 685 assert user.change_password_allowed?, "User not allowed to change password, though auth source does"
683 686
684 687 user.auth_source = denied_auth_source
685 688 assert !user.change_password_allowed?, "User allowed to change password, though auth source does not"
686 689 end
687 690
688 691 end
689 692
690 693 context "#allowed_to?" do
691 694 context "with a unique project" do
692 695 should "return false if project is archived" do
693 696 project = Project.find(1)
694 697 Project.any_instance.stubs(:status).returns(Project::STATUS_ARCHIVED)
695 698 assert ! @admin.allowed_to?(:view_issues, Project.find(1))
696 699 end
697 700
698 701 should "return false if related module is disabled" do
699 702 project = Project.find(1)
700 703 project.enabled_module_names = ["issue_tracking"]
701 704 assert @admin.allowed_to?(:add_issues, project)
702 705 assert ! @admin.allowed_to?(:view_wiki_pages, project)
703 706 end
704 707
705 708 should "authorize nearly everything for admin users" do
706 709 project = Project.find(1)
707 710 assert ! @admin.member_of?(project)
708 711 %w(edit_issues delete_issues manage_news manage_documents manage_wiki).each do |p|
709 712 assert @admin.allowed_to?(p.to_sym, project)
710 713 end
711 714 end
712 715
713 716 should "authorize normal users depending on their roles" do
714 717 project = Project.find(1)
715 718 assert @jsmith.allowed_to?(:delete_messages, project) #Manager
716 719 assert ! @dlopper.allowed_to?(:delete_messages, project) #Developper
717 720 end
718 721 end
719 722
720 723 context "with multiple projects" do
721 724 should "return false if array is empty" do
722 725 assert ! @admin.allowed_to?(:view_project, [])
723 726 end
724 727
725 728 should "return true only if user has permission on all these projects" do
726 729 assert @admin.allowed_to?(:view_project, Project.all)
727 730 assert ! @dlopper.allowed_to?(:view_project, Project.all) #cannot see Project(2)
728 731 assert @jsmith.allowed_to?(:edit_issues, @jsmith.projects) #Manager or Developer everywhere
729 732 assert ! @jsmith.allowed_to?(:delete_issue_watchers, @jsmith.projects) #Dev cannot delete_issue_watchers
730 733 end
731 734
732 735 should "behave correctly with arrays of 1 project" do
733 736 assert ! User.anonymous.allowed_to?(:delete_issues, [Project.first])
734 737 end
735 738 end
736 739
737 740 context "with options[:global]" do
738 741 should "authorize if user has at least one role that has this permission" do
739 742 @dlopper2 = User.find(5) #only Developper on a project, not Manager anywhere
740 743 @anonymous = User.find(6)
741 744 assert @jsmith.allowed_to?(:delete_issue_watchers, nil, :global => true)
742 745 assert ! @dlopper2.allowed_to?(:delete_issue_watchers, nil, :global => true)
743 746 assert @dlopper2.allowed_to?(:add_issues, nil, :global => true)
744 747 assert ! @anonymous.allowed_to?(:add_issues, nil, :global => true)
745 748 assert @anonymous.allowed_to?(:view_issues, nil, :global => true)
746 749 end
747 750 end
748 751 end
749 752
750 753 context "User#notify_about?" do
751 754 context "Issues" do
752 755 setup do
753 756 @project = Project.find(1)
754 757 @author = User.generate_with_protected!
755 758 @assignee = User.generate_with_protected!
756 759 @issue = Issue.generate_for_project!(@project, :assigned_to => @assignee, :author => @author)
757 760 end
758 761
759 762 should "be true for a user with :all" do
760 763 @author.update_attribute(:mail_notification, 'all')
761 764 assert @author.notify_about?(@issue)
762 765 end
763 766
764 767 should "be false for a user with :none" do
765 768 @author.update_attribute(:mail_notification, 'none')
766 769 assert ! @author.notify_about?(@issue)
767 770 end
768 771
769 772 should "be false for a user with :only_my_events and isn't an author, creator, or assignee" do
770 773 @user = User.generate_with_protected!(:mail_notification => 'only_my_events')
771 774 Member.create!(:user => @user, :project => @project, :role_ids => [1])
772 775 assert ! @user.notify_about?(@issue)
773 776 end
774 777
775 778 should "be true for a user with :only_my_events and is the author" do
776 779 @author.update_attribute(:mail_notification, 'only_my_events')
777 780 assert @author.notify_about?(@issue)
778 781 end
779 782
780 783 should "be true for a user with :only_my_events and is the assignee" do
781 784 @assignee.update_attribute(:mail_notification, 'only_my_events')
782 785 assert @assignee.notify_about?(@issue)
783 786 end
784 787
785 788 should "be true for a user with :only_assigned and is the assignee" do
786 789 @assignee.update_attribute(:mail_notification, 'only_assigned')
787 790 assert @assignee.notify_about?(@issue)
788 791 end
789 792
790 793 should "be false for a user with :only_assigned and is not the assignee" do
791 794 @author.update_attribute(:mail_notification, 'only_assigned')
792 795 assert ! @author.notify_about?(@issue)
793 796 end
794 797
795 798 should "be true for a user with :only_owner and is the author" do
796 799 @author.update_attribute(:mail_notification, 'only_owner')
797 800 assert @author.notify_about?(@issue)
798 801 end
799 802
800 803 should "be false for a user with :only_owner and is not the author" do
801 804 @assignee.update_attribute(:mail_notification, 'only_owner')
802 805 assert ! @assignee.notify_about?(@issue)
803 806 end
804 807
805 808 should "be true for a user with :selected and is the author" do
806 809 @author.update_attribute(:mail_notification, 'selected')
807 810 assert @author.notify_about?(@issue)
808 811 end
809 812
810 813 should "be true for a user with :selected and is the assignee" do
811 814 @assignee.update_attribute(:mail_notification, 'selected')
812 815 assert @assignee.notify_about?(@issue)
813 816 end
814 817
815 818 should "be false for a user with :selected and is not the author or assignee" do
816 819 @user = User.generate_with_protected!(:mail_notification => 'selected')
817 820 Member.create!(:user => @user, :project => @project, :role_ids => [1])
818 821 assert ! @user.notify_about?(@issue)
819 822 end
820 823 end
821 824
822 825 context "other events" do
823 826 should 'be added and tested'
824 827 end
825 828 end
826 829
827 830 def test_salt_unsalted_passwords
828 831 # Restore a user with an unsalted password
829 832 user = User.find(1)
830 833 user.salt = nil
831 834 user.hashed_password = User.hash_password("unsalted")
832 835 user.save!
833 836
834 837 User.salt_unsalted_passwords!
835 838
836 839 user.reload
837 840 # Salt added
838 841 assert !user.salt.blank?
839 842 # Password still valid
840 843 assert user.check_password?("unsalted")
841 844 assert_equal user, User.try_to_login(user.login, "unsalted")
842 845 end
843 846
844 847 if Object.const_defined?(:OpenID)
845 848
846 849 def test_setting_identity_url
847 850 normalized_open_id_url = 'http://example.com/'
848 851 u = User.new( :identity_url => 'http://example.com/' )
849 852 assert_equal normalized_open_id_url, u.identity_url
850 853 end
851 854
852 855 def test_setting_identity_url_without_trailing_slash
853 856 normalized_open_id_url = 'http://example.com/'
854 857 u = User.new( :identity_url => 'http://example.com' )
855 858 assert_equal normalized_open_id_url, u.identity_url
856 859 end
857 860
858 861 def test_setting_identity_url_without_protocol
859 862 normalized_open_id_url = 'http://example.com/'
860 863 u = User.new( :identity_url => 'example.com' )
861 864 assert_equal normalized_open_id_url, u.identity_url
862 865 end
863 866
864 867 def test_setting_blank_identity_url
865 868 u = User.new( :identity_url => 'example.com' )
866 869 u.identity_url = ''
867 870 assert u.identity_url.blank?
868 871 end
869 872
870 873 def test_setting_invalid_identity_url
871 874 u = User.new( :identity_url => 'this is not an openid url' )
872 875 assert u.identity_url.blank?
873 876 end
874 877
875 878 else
876 879 puts "Skipping openid tests."
877 880 end
878 881
879 882 end
General Comments 0
You need to be logged in to leave comments. Login now