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