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