test/controllers/user_controller_test.rb

   1 require "test_helper"
   2
   3 class UserControllerTest < ActionController::TestCase
   4   api_fixtures
   5   fixtures :messages
   6
   7   ##
   8   # test all routes which lead to this controller
   9   def test_routes
  10     assert_routing(
  11       { :path => "/api/0.6/user/1", :method => :get },
  12       { :controller => "user", :action => "api_read", :id => "1" }
  13     )
  14     assert_routing(
  15       { :path => "/api/0.6/user/details", :method => :get },
  16       { :controller => "user", :action => "api_details" }
  17     )
  18     assert_routing(
  19       { :path => "/api/0.6/user/gpx_files", :method => :get },
  20       { :controller => "user", :action => "api_gpx_files" }
  21     )
  22
  23     assert_routing(
  24       { :path => "/login", :method => :get },
  25       { :controller => "user", :action => "login" }
  26     )
  27     assert_routing(
  28       { :path => "/login", :method => :post },
  29       { :controller => "user", :action => "login" }
  30     )
  31     assert_recognizes(
  32       { :controller => "user", :action => "login", :format => "html" },
  33       { :path => "/login.html", :method => :get }
  34     )
  35
  36     assert_routing(
  37       { :path => "/logout", :method => :get },
  38       { :controller => "user", :action => "logout" }
  39     )
  40     assert_routing(
  41       { :path => "/logout", :method => :post },
  42       { :controller => "user", :action => "logout" }
  43     )
  44     assert_recognizes(
  45       { :controller => "user", :action => "logout", :format => "html" },
  46       { :path => "/logout.html", :method => :get }
  47     )
  48
  49     assert_routing(
  50       { :path => "/user/new", :method => :get },
  51       { :controller => "user", :action => "new" }
  52     )
  53
  54     assert_routing(
  55       { :path => "/user/new", :method => :post },
  56       { :controller => "user", :action => "create" }
  57     )
  58
  59     assert_routing(
  60       { :path => "/user/terms", :method => :get },
  61       { :controller => "user", :action => "terms" }
  62     )
  63
  64     assert_routing(
  65       { :path => "/user/save", :method => :post },
  66       { :controller => "user", :action => "save" }
  67     )
  68
  69     assert_routing(
  70       { :path => "/user/username/confirm", :method => :get },
  71       { :controller => "user", :action => "confirm", :display_name => "username" }
  72     )
  73     assert_routing(
  74       { :path => "/user/username/confirm", :method => :post },
  75       { :controller => "user", :action => "confirm", :display_name => "username" }
  76     )
  77     assert_routing(
  78       { :path => "/user/username/confirm/resend", :method => :get },
  79       { :controller => "user", :action => "confirm_resend", :display_name => "username" }
  80     )
  81
  82     assert_routing(
  83       { :path => "/user/confirm", :method => :get },
  84       { :controller => "user", :action => "confirm" }
  85     )
  86     assert_routing(
  87       { :path => "/user/confirm", :method => :post },
  88       { :controller => "user", :action => "confirm" }
  89     )
  90     assert_routing(
  91       { :path => "/user/confirm-email", :method => :get },
  92       { :controller => "user", :action => "confirm_email" }
  93     )
  94     assert_routing(
  95       { :path => "/user/confirm-email", :method => :post },
  96       { :controller => "user", :action => "confirm_email" }
  97     )
  98
  99     assert_routing(
 100       { :path => "/user/go_public", :method => :post },
 101       { :controller => "user", :action => "go_public" }
 102     )
 103
 104     assert_routing(
 105       { :path => "/user/forgot-password", :method => :get },
 106       { :controller => "user", :action => "lost_password" }
 107     )
 108     assert_routing(
 109       { :path => "/user/forgot-password", :method => :post },
 110       { :controller => "user", :action => "lost_password" }
 111     )
 112     assert_routing(
 113       { :path => "/user/reset-password", :method => :get },
 114       { :controller => "user", :action => "reset_password" }
 115     )
 116     assert_routing(
 117       { :path => "/user/reset-password", :method => :post },
 118       { :controller => "user", :action => "reset_password" }
 119     )
 120
 121     assert_routing(
 122       { :path => "/user/suspended", :method => :get },
 123       { :controller => "user", :action => "suspended" }
 124     )
 125
 126     assert_routing(
 127       { :path => "/user/username", :method => :get },
 128       { :controller => "user", :action => "view", :display_name => "username" }
 129     )
 130
 131     assert_routing(
 132       { :path => "/user/username/account", :method => :get },
 133       { :controller => "user", :action => "account", :display_name => "username" }
 134     )
 135     assert_routing(
 136       { :path => "/user/username/account", :method => :post },
 137       { :controller => "user", :action => "account", :display_name => "username" }
 138     )
 139
 140     assert_routing(
 141       { :path => "/user/username/make_friend", :method => :get },
 142       { :controller => "user", :action => "make_friend", :display_name => "username" }
 143     )
 144     assert_routing(
 145       { :path => "/user/username/make_friend", :method => :post },
 146       { :controller => "user", :action => "make_friend", :display_name => "username" }
 147     )
 148     assert_routing(
 149       { :path => "/user/username/remove_friend", :method => :get },
 150       { :controller => "user", :action => "remove_friend", :display_name => "username" }
 151     )
 152     assert_routing(
 153       { :path => "/user/username/remove_friend", :method => :post },
 154       { :controller => "user", :action => "remove_friend", :display_name => "username" }
 155     )
 156
 157     assert_routing(
 158       { :path => "/user/username/set_status", :method => :get },
 159       { :controller => "user", :action => "set_status", :display_name => "username" }
 160     )
 161     assert_routing(
 162       { :path => "/user/username/delete", :method => :get },
 163       { :controller => "user", :action => "delete", :display_name => "username" }
 164     )
 165
 166     assert_routing(
 167       { :path => "/users", :method => :get },
 168       { :controller => "user", :action => "list" }
 169     )
 170     assert_routing(
 171       { :path => "/users", :method => :post },
 172       { :controller => "user", :action => "list" }
 173     )
 174     assert_routing(
 175       { :path => "/users/status", :method => :get },
 176       { :controller => "user", :action => "list", :status => "status" }
 177     )
 178     assert_routing(
 179       { :path => "/users/status", :method => :post },
 180       { :controller => "user", :action => "list", :status => "status" }
 181     )
 182   end
 183
 184   # The user creation page loads
 185   def test_new_view
 186     get :new
 187     assert_response :redirect
 188     assert_redirected_to user_new_path(:cookie_test => "true")
 189
 190     get :new, { :cookie_test => "true" }, { :cookie_test => true }
 191     assert_response :success
 192
 193     assert_select "html", :count => 1 do
 194       assert_select "head", :count => 1 do
 195         assert_select "title", :text => /Sign Up/, :count => 1
 196       end
 197       assert_select "body", :count => 1 do
 198         assert_select "div#content", :count => 1 do
 199           assert_select "form[action='/user/new'][method='post']", :count => 1 do
 200             assert_select "input[id='user_email']", :count => 1
 201             assert_select "input[id='user_email_confirmation']", :count => 1
 202             assert_select "input[id='user_display_name']", :count => 1
 203             assert_select "input[id='user_pass_crypt'][type='password']", :count => 1
 204             assert_select "input[id='user_pass_crypt_confirmation'][type='password']", :count => 1
 205             assert_select "input[type='submit'][value='Sign Up']", :count => 1
 206           end
 207         end
 208       end
 209     end
 210   end
 211
 212   def test_new_view_logged_in
 213     session[:user] = users(:normal_user).id
 214
 215     get :new
 216     assert_response :redirect
 217     assert_redirected_to user_new_path(:cookie_test => "true")
 218     get :new, :cookie_test => "true"
 219     assert_response :redirect
 220     assert_redirected_to root_path
 221
 222     get :new, :referer => "/test"
 223     assert_response :redirect
 224     assert_redirected_to user_new_path(:referer => "/test", :cookie_test => "true")
 225     get :new, :referer => "/test", :cookie_test => "true"
 226     assert_response :redirect
 227     assert_redirected_to "/test"
 228   end
 229
 230   def test_new_success
 231     user = new_user
 232
 233     assert_difference "User.count", 1 do
 234       assert_difference "ActionMailer::Base.deliveries.size", 1 do
 235         post :save, {}, { :new_user => user }
 236       end
 237     end
 238
 239     # Check the e-mail
 240     register_email = ActionMailer::Base.deliveries.first
 241
 242     assert_equal register_email.to[0], user.email
 243     assert_match /#{@url}/, register_email.body.to_s
 244
 245     # Check the page
 246     assert_redirected_to :action => "confirm", :display_name => user.display_name
 247
 248     ActionMailer::Base.deliveries.clear
 249   end
 250
 251   def test_new_duplicate_email
 252     user = new_user
 253     user.email = users(:public_user).email
 254
 255     assert_no_difference "User.count" do
 256       assert_no_difference "ActionMailer::Base.deliveries.size" do
 257         post :save, {}, { :new_user => user }
 258       end
 259     end
 260
 261     assert_response :success
 262     assert_template "new"
 263     assert_select "form > fieldset > div.form-row > input.field_with_errors#user_email"
 264   end
 265
 266   def test_new_duplicate_email_uppercase
 267     user = new_user
 268     user.email = users(:public_user).email.upcase
 269
 270     assert_no_difference "User.count" do
 271       assert_no_difference "ActionMailer::Base.deliveries.size" do
 272         post :save, {}, { :new_user => user }
 273       end
 274     end
 275
 276     assert_response :success
 277     assert_template "new"
 278     assert_select "form > fieldset > div.form-row > input.field_with_errors#user_email"
 279   end
 280
 281   def test_new_duplicate_name
 282     user = new_user
 283     user.display_name = users(:public_user).display_name
 284
 285     assert_no_difference "User.count" do
 286       assert_no_difference "ActionMailer::Base.deliveries.size" do
 287         post :save, {}, { :new_user => user }
 288       end
 289     end
 290
 291     assert_response :success
 292     assert_template "new"
 293     assert_select "form > fieldset > div.form-row > input.field_with_errors#user_display_name"
 294   end
 295
 296   def test_new_duplicate_name_uppercase
 297     user = new_user
 298     user.display_name = users(:public_user).display_name.upcase
 299
 300     assert_no_difference "User.count" do
 301       assert_no_difference "ActionMailer::Base.deliveries.size" do
 302         post :save, {}, { :new_user => user }
 303       end
 304     end
 305
 306     assert_response :success
 307     assert_template "new"
 308     assert_select "form > fieldset > div.form-row > input.field_with_errors#user_display_name"
 309   end
 310
 311   def test_save_referer_params
 312     user = new_user
 313
 314     assert_difference "User.count", 1 do
 315       assert_difference "ActionMailer::Base.deliveries.size", 1 do
 316         post :save, {}, { :new_user => user,
 317                           :referer => "/edit?editor=id#map=1/2/3" }
 318       end
 319     end
 320
 321     assert_equal welcome_path(:editor => "id", :zoom => 1, :lat => 2, :lon => 3),
 322                  user.tokens.order("id DESC").first.referer
 323
 324     ActionMailer::Base.deliveries.clear
 325   end
 326
 327   def test_logout_without_referer
 328     get :logout
 329     assert_response :success
 330     assert_template :logout
 331     assert_select "input[name=referer][value=?]", ""
 332
 333     session_id = assert_select("input[name=session]").first["value"]
 334
 335     get :logout, :session => session_id
 336     assert_response :redirect
 337     assert_redirected_to root_path
 338   end
 339
 340   def test_logout_with_referer
 341     get :logout, :referer => "/test"
 342     assert_response :success
 343     assert_template :logout
 344     assert_select "input[name=referer][value=?]", "/test"
 345
 346     session_id = assert_select("input[name=session]").first["value"]
 347
 348     get :logout, :session => session_id, :referer => "/test"
 349     assert_response :redirect
 350     assert_redirected_to "/test"
 351   end
 352
 353   def test_logout_with_token
 354     token = users(:normal_user).tokens.create
 355
 356     session[:token] = token.token
 357
 358     get :logout
 359     assert_response :success
 360     assert_template :logout
 361     assert_select "input[name=referer][value=?]", ""
 362     assert_equal token.token, session[:token]
 363     assert_not_nil UserToken.where(:id => token.id).first
 364
 365     session_id = assert_select("input[name=session]").first["value"]
 366
 367     get :logout, :session => session_id
 368     assert_response :redirect
 369     assert_redirected_to root_path
 370     assert_nil session[:token]
 371     assert_nil UserToken.where(:id => token.id).first
 372   end
 373
 374   def test_confirm_get
 375     user = users(:inactive_user)
 376     confirm_string = user.tokens.create.token
 377
 378     @request.cookies["_osm_session"] = user.display_name
 379     get :confirm, :display_name => user.display_name, :confirm_string => confirm_string
 380     assert_response :success
 381     assert_template :confirm
 382   end
 383
 384   def test_confirm_get_already_confirmed
 385     user = users(:normal_user)
 386     confirm_string = user.tokens.create.token
 387
 388     @request.cookies["_osm_session"] = user.display_name
 389     get :confirm, :display_name => user.display_name, :confirm_string => confirm_string
 390     assert_response :redirect
 391     assert_redirected_to root_path
 392   end
 393
 394   def test_confirm_success_no_token_no_referer
 395     user = users(:inactive_user)
 396     confirm_string = user.tokens.create.token
 397
 398     @request.cookies["_osm_session"] = user.display_name
 399     post :confirm, :display_name => user.display_name, :confirm_string => confirm_string
 400     assert_redirected_to login_path
 401     assert_match /Confirmed your account/, flash[:notice]
 402   end
 403
 404   def test_confirm_success_good_token_no_referer
 405     user = users(:inactive_user)
 406     confirm_string = user.tokens.create.token
 407     token = user.tokens.create.token
 408
 409     @request.cookies["_osm_session"] = user.display_name
 410     post :confirm, { :display_name => user.display_name, :confirm_string => confirm_string }, { :token => token }
 411     assert_redirected_to welcome_path
 412   end
 413
 414   def test_confirm_success_bad_token_no_referer
 415     user = users(:inactive_user)
 416     confirm_string = user.tokens.create.token
 417     token = users(:normal_user).tokens.create.token
 418
 419     @request.cookies["_osm_session"] = user.display_name
 420     post :confirm, { :display_name => user.display_name, :confirm_string => confirm_string }, { :token => token }
 421     assert_redirected_to login_path
 422     assert_match /Confirmed your account/, flash[:notice]
 423   end
 424
 425   def test_confirm_success_no_token_with_referer
 426     user = users(:inactive_user)
 427     confirm_string = user.tokens.create(:referer => diary_new_path).token
 428
 429     @request.cookies["_osm_session"] = user.display_name
 430     post :confirm, :display_name => user.display_name, :confirm_string => confirm_string
 431     assert_redirected_to login_path(:referer => diary_new_path)
 432     assert_match /Confirmed your account/, flash[:notice]
 433   end
 434
 435   def test_confirm_success_good_token_with_referer
 436     user = users(:inactive_user)
 437     confirm_string = user.tokens.create(:referer => diary_new_path).token
 438     token = user.tokens.create.token
 439
 440     @request.cookies["_osm_session"] = user.display_name
 441     post :confirm, { :display_name => user.display_name, :confirm_string => confirm_string }, { :token => token }
 442     assert_redirected_to diary_new_path
 443   end
 444
 445   def test_confirm_success_bad_token_with_referer
 446     user = users(:inactive_user)
 447     confirm_string = user.tokens.create(:referer => diary_new_path).token
 448     token = users(:normal_user).tokens.create.token
 449
 450     @request.cookies["_osm_session"] = user.display_name
 451     post :confirm, { :display_name => user.display_name, :confirm_string => confirm_string }, { :token => token }
 452     assert_redirected_to login_path(:referer => diary_new_path)
 453     assert_match /Confirmed your account/, flash[:notice]
 454   end
 455
 456   def test_confirm_expired_token
 457     user = users(:inactive_user)
 458     confirm_string = user.tokens.create(:expiry => 1.day.ago).token
 459
 460     @request.cookies["_osm_session"] = user.display_name
 461     post :confirm, :display_name => user.display_name, :confirm_string => confirm_string
 462     assert_redirected_to :action => "confirm"
 463     assert_match /confirmation code has expired/, flash[:error]
 464   end
 465
 466   def test_confirm_already_confirmed
 467     user = users(:normal_user)
 468     confirm_string = user.tokens.create(:referer => diary_new_path).token
 469
 470     @request.cookies["_osm_session"] = user.display_name
 471     post :confirm, :display_name => user.display_name, :confirm_string => confirm_string
 472     assert_redirected_to :action => "login"
 473     assert_match /already been confirmed/, flash[:error]
 474   end
 475
 476   def test_confirm_resend_success
 477     session[:token] = users(:inactive_user).tokens.create.token
 478
 479     assert_difference "ActionMailer::Base.deliveries.size", 1 do
 480       get :confirm_resend, :display_name => users(:inactive_user).display_name
 481     end
 482
 483     assert_response :redirect
 484     assert_redirected_to login_path
 485     assert_match /sent a new confirmation/, flash[:notice]
 486
 487     email = ActionMailer::Base.deliveries.last
 488
 489     assert_equal users(:inactive_user).email, email.to.first
 490
 491     ActionMailer::Base.deliveries.clear
 492   end
 493
 494   def test_confirm_resend_no_token
 495     assert_no_difference "ActionMailer::Base.deliveries.size" do
 496       get :confirm_resend, :display_name => users(:inactive_user).display_name
 497     end
 498
 499     assert_response :redirect
 500     assert_redirected_to login_path
 501     assert_match "User Inactive User not found.", flash[:error]
 502   end
 503
 504   def test_confirm_resend_unknown_user
 505     assert_no_difference "ActionMailer::Base.deliveries.size" do
 506       get :confirm_resend, :display_name => "No Such User"
 507     end
 508
 509     assert_response :redirect
 510     assert_redirected_to login_path
 511     assert_match "User No Such User not found.", flash[:error]
 512   end
 513
 514   def test_confirm_email_get
 515     user = users(:normal_user)
 516     confirm_string = user.tokens.create.token
 517
 518     get :confirm_email, :confirm_string => confirm_string
 519     assert_response :success
 520     assert_template :confirm_email
 521   end
 522
 523   def test_confirm_email_success
 524     user = users(:second_public_user)
 525     confirm_string = user.tokens.create.token
 526
 527     post :confirm_email, :confirm_string => confirm_string
 528     assert_response :redirect
 529     assert_redirected_to :action => :account, :display_name => user.display_name
 530     assert_match /Confirmed your change of email address/, flash[:notice]
 531   end
 532
 533   def test_confirm_email_already_confirmed
 534     user = users(:normal_user)
 535     confirm_string = user.tokens.create.token
 536
 537     post :confirm_email, :confirm_string => confirm_string
 538     assert_response :redirect
 539     assert_redirected_to :action => :account, :display_name => user.display_name
 540     assert_match /already been confirmed/, flash[:error]
 541   end
 542
 543   def test_confirm_email_bad_token
 544     post :confirm_email, :confirm_string => "XXXXX"
 545     assert_response :success
 546     assert_template :confirm_email
 547     assert_match /confirmation code has expired or does not exist/, flash[:error]
 548   end
 549
 550   ##
 551   # test if testing for a gravatar works
 552   # this happens when the email is actually changed
 553   # which is triggered by the confirmation mail
 554   def test_gravatar_auto_enable
 555     with_http_stubs "gravatar" do
 556       # switch to email that has a gravatar
 557       user = users(:first_gravatar_user)
 558       confirm_string = user.tokens.create.token
 559       # precondition gravatar should be turned off
 560       assert !user.image_use_gravatar
 561       post :confirm_email, :confirm_string => confirm_string
 562       assert_response :redirect
 563       assert_redirected_to :action => :account, :display_name => user.display_name
 564       assert_match /Confirmed your change of email address/, flash[:notice]
 565       # gravatar use should now be enabled
 566       assert User.find(users(:first_gravatar_user).id).image_use_gravatar
 567     end
 568   end
 569
 570   def test_gravatar_auto_disable
 571     with_http_stubs "gravatar" do
 572       # switch to email without a gravatar
 573       user = users(:second_gravatar_user)
 574       confirm_string = user.tokens.create.token
 575       # precondition gravatar should be turned on
 576       assert user.image_use_gravatar
 577       post :confirm_email, :confirm_string => confirm_string
 578       assert_response :redirect
 579       assert_redirected_to :action => :account, :display_name => user.display_name
 580       assert_match /Confirmed your change of email address/, flash[:notice]
 581       # gravatar use should now be disabled
 582       assert !User.find(users(:second_gravatar_user).id).image_use_gravatar
 583     end
 584   end
 585
 586   def test_terms_new_user
 587     get :terms, {}, { :new_user => User.new }
 588     assert_response :success
 589     assert_template :terms
 590   end
 591
 592   def test_terms_seen
 593     user = users(:normal_user)
 594
 595     session[:user] = user.id
 596
 597     get :terms
 598     assert_response :redirect
 599     assert_redirected_to :action => :account, :display_name => user.display_name
 600   end
 601
 602   def test_terms_not_seen_without_referer
 603     user = users(:terms_not_seen_user)
 604
 605     session[:user] = user.id
 606
 607     get :terms
 608     assert_response :success
 609     assert_template :terms
 610
 611     post :save, :user => { :consider_pd => true }
 612     assert_response :redirect
 613     assert_redirected_to :action => :account, :display_name => user.display_name
 614     assert_equal "Thanks for accepting the new contributor terms!", flash[:notice]
 615
 616     user.reload
 617
 618     assert_equal true, user.consider_pd
 619     assert_not_nil user.terms_agreed
 620     assert_equal true, user.terms_seen
 621   end
 622
 623   def test_terms_not_seen_with_referer
 624     user = users(:terms_not_seen_user)
 625
 626     session[:user] = user.id
 627
 628     get :terms, :referer => "/test"
 629     assert_response :success
 630     assert_template :terms
 631
 632     post :save, :user => { :consider_pd => true }, :referer => "/test"
 633     assert_response :redirect
 634     assert_redirected_to "/test"
 635     assert_equal "Thanks for accepting the new contributor terms!", flash[:notice]
 636
 637     user.reload
 638
 639     assert_equal true, user.consider_pd
 640     assert_not_nil user.terms_agreed
 641     assert_equal true, user.terms_seen
 642   end
 643
 644   def test_go_public
 645     post :go_public, {}, { :user => users(:normal_user) }
 646     assert_response :redirect
 647     assert_redirected_to :action => :account, :display_name => users(:normal_user).display_name
 648     assert_equal true, User.find(users(:normal_user).id).data_public
 649   end
 650
 651   def test_lost_password
 652     # Test fetching the lost password page
 653     get :lost_password
 654     assert_response :success
 655     assert_template :lost_password
 656     assert_select "div#notice", false
 657
 658     # Test resetting using the address as recorded for a user that has an
 659     # address which is duplicated in a different case by another user
 660     assert_difference "ActionMailer::Base.deliveries.size", 1 do
 661       post :lost_password, :user => { :email => users(:normal_user).email }
 662     end
 663     assert_response :redirect
 664     assert_redirected_to :action => :login
 665     assert_match /^Sorry you lost it/, flash[:notice]
 666     email = ActionMailer::Base.deliveries.first
 667     assert_equal 1, email.to.count
 668     assert_equal users(:normal_user).email, email.to.first
 669     ActionMailer::Base.deliveries.clear
 670
 671     # Test resetting using an address that matches a different user
 672     # that has the same address in a different case
 673     assert_difference "ActionMailer::Base.deliveries.size", 1 do
 674       post :lost_password, :user => { :email => users(:normal_user).email.upcase }
 675     end
 676     assert_response :redirect
 677     assert_redirected_to :action => :login
 678     assert_match /^Sorry you lost it/, flash[:notice]
 679     email = ActionMailer::Base.deliveries.first
 680     assert_equal 1, email.to.count
 681     assert_equal users(:uppercase_user).email, email.to.first
 682     ActionMailer::Base.deliveries.clear
 683
 684     # Test resetting using an address that is a case insensitive match
 685     # for more than one user but not an exact match for either
 686     assert_no_difference "ActionMailer::Base.deliveries.size" do
 687       post :lost_password, :user => { :email => users(:normal_user).email.titlecase }
 688     end
 689     assert_response :success
 690     assert_template :lost_password
 691     assert_select ".error", /^Could not find that email address/
 692
 693     # Test resetting using the address as recorded for a user that has an
 694     # address which is case insensitively unique
 695     assert_difference "ActionMailer::Base.deliveries.size", 1 do
 696       post :lost_password, :user => { :email => users(:public_user).email }
 697     end
 698     assert_response :redirect
 699     assert_redirected_to :action => :login
 700     assert_match /^Sorry you lost it/, flash[:notice]
 701     email = ActionMailer::Base.deliveries.first
 702     assert_equal 1, email.to.count
 703     assert_equal users(:public_user).email, email.to.first
 704     ActionMailer::Base.deliveries.clear
 705
 706     # Test resetting using an address that matches a user that has the
 707     # same (case insensitively unique) address in a different case
 708     assert_difference "ActionMailer::Base.deliveries.size", 1 do
 709       post :lost_password, :user => { :email => users(:public_user).email.upcase }
 710     end
 711     assert_response :redirect
 712     assert_redirected_to :action => :login
 713     assert_match /^Sorry you lost it/, flash[:notice]
 714     email = ActionMailer::Base.deliveries.first
 715     assert_equal 1, email.to.count
 716     assert_equal users(:public_user).email, email.to.first
 717     ActionMailer::Base.deliveries.clear
 718   end
 719
 720   def test_reset_password
 721     # Test a request with no token
 722     get :reset_password
 723     assert_response :bad_request
 724
 725     # Test a request with a bogus token
 726     get :reset_password, :token => "made_up_token"
 727     assert_response :redirect
 728     assert_redirected_to :action => :lost_password
 729
 730     # Create a valid token for a user
 731     token = User.find(users(:inactive_user).id).tokens.create
 732
 733     # Test a request with a valid token
 734     get :reset_password, :token => token.token
 735     assert_response :success
 736     assert_template :reset_password
 737
 738     # Test setting a new password
 739     post :reset_password, :token => token.token, :user => { :pass_crypt => "new_password", :pass_crypt_confirmation => "new_password" }
 740     assert_response :redirect
 741     assert_redirected_to root_path
 742     assert_equal users(:inactive_user).id, session[:user]
 743     user = User.find(users(:inactive_user).id)
 744     assert_equal "active", user.status
 745     assert_equal true, user.email_valid
 746     assert_equal user, User.authenticate(:username => "inactive@openstreetmap.org", :password => "new_password")
 747   end
 748
 749   def test_account
 750     # Get a user to work with - note that this user deliberately
 751     # conflicts with uppercase_user in the email and display name
 752     # fields to test that we can change other fields without any
 753     # validation errors being reported
 754     user = users(:normal_user)
 755
 756     # Make sure that you are redirected to the login page when
 757     # you are not logged in
 758     get :account, :display_name => user.display_name
 759     assert_response :redirect
 760     assert_redirected_to :controller => :user, :action => "login", :referer => "/user/test/account"
 761
 762     # Make sure that you are blocked when not logged in as the right user
 763     get :account, { :display_name => user.display_name }, { :user => users(:public_user).id }
 764     assert_response :forbidden
 765
 766     # Make sure we get the page when we are logged in as the right user
 767     get :account, { :display_name => user.display_name }, { :user => user }
 768     assert_response :success
 769     assert_template :account
 770
 771     # Updating the description should work
 772     user.description = "new description"
 773     post :account, { :display_name => user.display_name, :user => user.attributes }, { :user => user.id }
 774     assert_response :success
 775     assert_template :account
 776     assert_select "div#errorExplanation", false
 777     assert_select ".notice", /^User information updated successfully/
 778     assert_select "form#accountForm > fieldset > div.form-row > div#user_description_container > div#user_description_content > textarea#user_description", user.description
 779
 780     # Changing to a invalid editor should fail
 781     user.preferred_editor = "unknown"
 782     post :account, { :display_name => user.display_name, :user => user.attributes }, { :user => user.id }
 783     assert_response :success
 784     assert_template :account
 785     assert_select ".notice", false
 786     assert_select "div#errorExplanation"
 787     assert_select "form#accountForm > fieldset > div.form-row > select#user_preferred_editor > option[selected]", false
 788
 789     # Changing to a valid editor should work
 790     user.preferred_editor = "potlatch2"
 791     post :account, { :display_name => user.display_name, :user => user.attributes }, { :user => user.id }
 792     assert_response :success
 793     assert_template :account
 794     assert_select "div#errorExplanation", false
 795     assert_select ".notice", /^User information updated successfully/
 796     assert_select "form#accountForm > fieldset > div.form-row > select#user_preferred_editor > option[selected][value=?]", "potlatch2"
 797
 798     # Changing to the default editor should work
 799     user.preferred_editor = "default"
 800     post :account, { :display_name => user.display_name, :user => user.attributes }, { :user => user.id }
 801     assert_response :success
 802     assert_template :account
 803     assert_select "div#errorExplanation", false
 804     assert_select ".notice", /^User information updated successfully/
 805     assert_select "form#accountForm > fieldset > div.form-row > select#user_preferred_editor > option[selected]", false
 806
 807     # Changing to an uploaded image should work
 808     image = Rack::Test::UploadedFile.new("test/traces/1.gif", "image/gif")
 809     post :account, { :display_name => user.display_name, :image_action => "new", :user => user.attributes.merge(:image => image) }, { :user => user.id }
 810     assert_response :success
 811     assert_template :account
 812     assert_select "div#errorExplanation", false
 813     assert_select ".notice", /^User information updated successfully/
 814     assert_select "form#accountForm > fieldset > div.form-row.accountImage input[name=image_action][checked][value=?]", "keep"
 815
 816     # Changing to a gravatar image should work
 817     post :account, { :display_name => user.display_name, :image_action => "gravatar", :user => user.attributes }, { :user => user.id }
 818     assert_response :success
 819     assert_template :account
 820     assert_select "div#errorExplanation", false
 821     assert_select ".notice", /^User information updated successfully/
 822     assert_select "form#accountForm > fieldset > div.form-row.accountImage input[name=image_action][checked][value=?]", "gravatar"
 823
 824     # Removing the image should work
 825     post :account, { :display_name => user.display_name, :image_action => "delete", :user => user.attributes }, { :user => user.id }
 826     assert_response :success
 827     assert_template :account
 828     assert_select "div#errorExplanation", false
 829     assert_select ".notice", /^User information updated successfully/
 830     assert_select "form#accountForm > fieldset > div.form-row.accountImage input[name=image_action][checked]", false
 831
 832     # Adding external authentication should redirect to the auth provider
 833     post :account, { :display_name => user.display_name, :user => user.attributes.merge(:auth_provider => "openid", :auth_uid => "gmail.com") }, { :user => user.id }
 834     assert_response :redirect
 835     assert_redirected_to auth_path(:provider => "openid", :openid_url => "https://www.google.com/accounts/o8/id", :origin => "/user/#{user.display_name}/account")
 836
 837     # Changing name to one that exists should fail
 838     new_attributes = user.attributes.dup.merge(:display_name => users(:public_user).display_name)
 839     post :account, { :display_name => user.display_name, :user => new_attributes }, { :user => user.id }
 840     assert_response :success
 841     assert_template :account
 842     assert_select ".notice", false
 843     assert_select "div#errorExplanation"
 844     assert_select "form#accountForm > fieldset > div.form-row > input.field_with_errors#user_display_name"
 845
 846     # Changing name to one that exists should fail, regardless of case
 847     new_attributes = user.attributes.dup.merge(:display_name => users(:public_user).display_name.upcase)
 848     post :account, { :display_name => user.display_name, :user => new_attributes }, { :user => user.id }
 849     assert_response :success
 850     assert_template :account
 851     assert_select ".notice", false
 852     assert_select "div#errorExplanation"
 853     assert_select "form#accountForm > fieldset > div.form-row > input.field_with_errors#user_display_name"
 854
 855     # Changing name to one that doesn't exist should work
 856     new_attributes = user.attributes.dup.merge(:display_name => "new tester")
 857     post :account, { :display_name => user.display_name, :user => new_attributes }, { :user => user.id }
 858     assert_response :success
 859     assert_template :account
 860     assert_select "div#errorExplanation", false
 861     assert_select ".notice", /^User information updated successfully/
 862     assert_select "form#accountForm > fieldset > div.form-row > input#user_display_name[value=?]", "new tester"
 863
 864     # Record the change of name
 865     user.display_name = "new tester"
 866
 867     # Changing email to one that exists should fail
 868     user.new_email = users(:public_user).email
 869     assert_no_difference "ActionMailer::Base.deliveries.size" do
 870       post :account, { :display_name => user.display_name, :user => user.attributes }, { :user => user.id }
 871     end
 872     assert_response :success
 873     assert_template :account
 874     assert_select ".notice", false
 875     assert_select "div#errorExplanation"
 876     assert_select "form#accountForm > fieldset > div.form-row > input.field_with_errors#user_new_email"
 877
 878     # Changing email to one that exists should fail, regardless of case
 879     user.new_email = users(:public_user).email.upcase
 880     assert_no_difference "ActionMailer::Base.deliveries.size" do
 881       post :account, { :display_name => user.display_name, :user => user.attributes }, { :user => user.id }
 882     end
 883     assert_response :success
 884     assert_template :account
 885     assert_select ".notice", false
 886     assert_select "div#errorExplanation"
 887     assert_select "form#accountForm > fieldset > div.form-row > input.field_with_errors#user_new_email"
 888
 889     # Changing email to one that doesn't exist should work
 890     user.new_email = "new_tester@example.com"
 891     assert_difference "ActionMailer::Base.deliveries.size", 1 do
 892       post :account, { :display_name => user.display_name, :user => user.attributes }, { :user => user.id }
 893     end
 894     assert_response :success
 895     assert_template :account
 896     assert_select "div#errorExplanation", false
 897     assert_select ".notice", /^User information updated successfully/
 898     assert_select "form#accountForm > fieldset > div.form-row > input#user_new_email[value=?]", user.new_email
 899     email = ActionMailer::Base.deliveries.first
 900     assert_equal 1, email.to.count
 901     assert_equal user.new_email, email.to.first
 902     ActionMailer::Base.deliveries.clear
 903   end
 904
 905   # Check that the user account page will display and contains some relevant
 906   # information for the user
 907   def test_view
 908     # Test a non-existent user
 909     get :view, :display_name => "unknown"
 910     assert_response :not_found
 911
 912     # Test a normal user
 913     get :view, :display_name => "test"
 914     assert_response :success
 915     assert_select "div#userinformation" do
 916       assert_select "a[href^='/user/test/history']", 1
 917       assert_select "a[href='/user/test/traces']", 1
 918       assert_select "a[href='/user/test/diary']", 1
 919       assert_select "a[href='/user/test/diary/comments']", 1
 920       assert_select "a[href='/user/test/account']", 0
 921       assert_select "a[href='/user/test/blocks']", 0
 922       assert_select "a[href='/user/test/blocks_by']", 0
 923       assert_select "a[href='/blocks/new/test']", 0
 924     end
 925
 926     # Test a user who has been blocked
 927     get :view, :display_name => "blocked"
 928     assert_response :success
 929     assert_select "div#userinformation" do
 930       assert_select "a[href^='/user/blocked/history']", 1
 931       assert_select "a[href='/user/blocked/traces']", 1
 932       assert_select "a[href='/user/blocked/diary']", 1
 933       assert_select "a[href='/user/blocked/diary/comments']", 1
 934       assert_select "a[href='/user/blocked/account']", 0
 935       assert_select "a[href='/user/blocked/blocks']", 1
 936       assert_select "a[href='/user/blocked/blocks_by']", 0
 937       assert_select "a[href='/blocks/new/blocked']", 0
 938     end
 939
 940     # Test a moderator who has applied blocks
 941     get :view, :display_name => "moderator"
 942     assert_response :success
 943     assert_select "div#userinformation" do
 944       assert_select "a[href^='/user/moderator/history']", 1
 945       assert_select "a[href='/user/moderator/traces']", 1
 946       assert_select "a[href='/user/moderator/diary']", 1
 947       assert_select "a[href='/user/moderator/diary/comments']", 1
 948       assert_select "a[href='/user/moderator/account']", 0
 949       assert_select "a[href='/user/moderator/blocks']", 0
 950       assert_select "a[href='/user/moderator/blocks_by']", 1
 951       assert_select "a[href='/blocks/new/moderator']", 0
 952     end
 953
 954     # Login as a normal user
 955     session[:user] = users(:normal_user).id
 956
 957     # Test the normal user
 958     get :view, :display_name => "test"
 959     assert_response :success
 960     assert_select "div#userinformation" do
 961       assert_select "a[href^='/user/test/history']", 1
 962       assert_select "a[href='/traces/mine']", 1
 963       assert_select "a[href='/user/test/diary']", 1
 964       assert_select "a[href='/user/test/diary/comments']", 1
 965       assert_select "a[href='/user/test/account']", 1
 966       assert_select "a[href='/user/test/blocks']", 0
 967       assert_select "a[href='/user/test/blocks_by']", 0
 968       assert_select "a[href='/blocks/new/test']", 0
 969     end
 970
 971     # Login as a moderator
 972     session[:user] = users(:moderator_user).id
 973
 974     # Test the normal user
 975     get :view, :display_name => "test"
 976     assert_response :success
 977     assert_select "div#userinformation" do
 978       assert_select "a[href^='/user/test/history']", 1
 979       assert_select "a[href='/user/test/traces']", 1
 980       assert_select "a[href='/user/test/diary']", 1
 981       assert_select "a[href='/user/test/diary/comments']", 1
 982       assert_select "a[href='/user/test/account']", 0
 983       assert_select "a[href='/user/test/blocks']", 0
 984       assert_select "a[href='/user/test/blocks_by']", 0
 985       assert_select "a[href='/blocks/new/test']", 1
 986     end
 987   end
 988
 989   def test_api_read
 990     # check that a visible user is returned properly
 991     get :api_read, :id => users(:normal_user).id
 992     assert_response :success
 993     assert_equal "text/xml", response.content_type
 994
 995     # check the data that is returned
 996     assert_select "description", :count => 1, :text => "test"
 997     assert_select "contributor-terms", :count => 1 do
 998       assert_select "[agreed='true']"
 999     end
1000     assert_select "img", :count => 0
1001     assert_select "roles", :count => 1 do
1002       assert_select "role", :count => 0
1003     end
1004     assert_select "changesets", :count => 1 do
1005       assert_select "[count='0']"
1006     end
1007     assert_select "traces", :count => 1 do
1008       assert_select "[count='0']"
1009     end
1010     assert_select "blocks", :count => 1 do
1011       assert_select "received", :count => 1 do
1012         assert_select "[count='0'][active='0']"
1013       end
1014       assert_select "issued", :count => 0
1015     end
1016
1017     # check that we aren't revealing private information
1018     assert_select "contributor-terms[pd]", false
1019     assert_select "home", false
1020     assert_select "languages", false
1021     assert_select "messages", false
1022
1023     # check that a suspended user is not returned
1024     get :api_read, :id => users(:suspended_user).id
1025     assert_response :gone
1026
1027     # check that a deleted user is not returned
1028     get :api_read, :id => users(:deleted_user).id
1029     assert_response :gone
1030
1031     # check that a non-existent user is not returned
1032     get :api_read, :id => 0
1033     assert_response :not_found
1034   end
1035
1036   def test_api_details
1037     # check that nothing is returned when not logged in
1038     get :api_details
1039     assert_response :unauthorized
1040
1041     # check that we get a response when logged in
1042     basic_authorization(users(:normal_user).email, "test")
1043     get :api_details
1044     assert_response :success
1045     assert_equal "text/xml", response.content_type
1046
1047     # check the data that is returned
1048     assert_select "description", :count => 1, :text => "test"
1049     assert_select "contributor-terms", :count => 1 do
1050       assert_select "[agreed='true'][pd='false']"
1051     end
1052     assert_select "img", :count => 0
1053     assert_select "roles", :count => 1 do
1054       assert_select "role", :count => 0
1055     end
1056     assert_select "changesets", :count => 1 do
1057       assert_select "[count='0']", :count => 1
1058     end
1059     assert_select "traces", :count => 1 do
1060       assert_select "[count='0']", :count => 1
1061     end
1062     assert_select "blocks", :count => 1 do
1063       assert_select "received", :count => 1 do
1064         assert_select "[count='0'][active='0']"
1065       end
1066       assert_select "issued", :count => 0
1067     end
1068     assert_select "home", :count => 1 do
1069       assert_select "[lat='12.1'][lon='12.1'][zoom='3']"
1070     end
1071     assert_select "languages", :count => 1 do
1072       assert_select "lang", :count => 1, :text => "en"
1073     end
1074     assert_select "messages", :count => 1 do
1075       assert_select "received", :count => 1 do
1076         assert_select "[count='1'][unread='0']"
1077       end
1078       assert_select "sent", :count => 1 do
1079         assert_select "[count='1']"
1080       end
1081     end
1082   end
1083
1084   def test_api_gpx_files
1085     # check that nothing is returned when not logged in
1086     get :api_gpx_files
1087     assert_response :unauthorized
1088
1089     # check that we get a response when logged in
1090     basic_authorization(users(:normal_user).email, "test")
1091     get :api_gpx_files
1092     assert_response :success
1093     assert_equal "text/xml", response.content_type
1094
1095     # check the data that is returned
1096     assert_select "gpx_file[id='1']", 1 do
1097       assert_select "tag", "London"
1098     end
1099     assert_select "gpx_file[id='4']", 1 do
1100       assert_select "tag", "Birmingham"
1101     end
1102   end
1103
1104   def test_make_friend
1105     # Get users to work with
1106     user = users(:normal_user)
1107     friend = users(:second_public_user)
1108
1109     # Check that the users aren't already friends
1110     assert_nil Friend.where(:user_id => user.id, :friend_user_id => friend.id).first
1111
1112     # When not logged in a GET should ask us to login
1113     get :make_friend, :display_name => friend.display_name
1114     assert_redirected_to :controller => :user, :action => "login", :referer => make_friend_path(:display_name => friend.display_name)
1115
1116     # When not logged in a POST should error
1117     post :make_friend, :display_name => friend.display_name
1118     assert_response :forbidden
1119     assert_nil Friend.where(:user_id => user.id, :friend_user_id => friend.id).first
1120
1121     # When logged in a GET should get a confirmation page
1122     get :make_friend, { :display_name => friend.display_name }, { :user => user.id }
1123     assert_response :success
1124     assert_template :make_friend
1125     assert_select "form" do
1126       assert_select "input[type='hidden'][name='referer']", 0
1127       assert_select "input[type='submit']", 1
1128     end
1129     assert_nil Friend.where(:user_id => user.id, :friend_user_id => friend.id).first
1130
1131     # When logged in a POST should add the friendship
1132     assert_difference "ActionMailer::Base.deliveries.size", 1 do
1133       post :make_friend, { :display_name => friend.display_name }, { :user => user.id }
1134     end
1135     assert_redirected_to user_path(:display_name => friend.display_name)
1136     assert_match /is now your friend/, flash[:notice]
1137     assert Friend.where(:user_id => user.id, :friend_user_id => friend.id).first
1138     email = ActionMailer::Base.deliveries.first
1139     assert_equal 1, email.to.count
1140     assert_equal friend.email, email.to.first
1141     ActionMailer::Base.deliveries.clear
1142
1143     # A second POST should report that the friendship already exists
1144     assert_no_difference "ActionMailer::Base.deliveries.size" do
1145       post :make_friend, { :display_name => friend.display_name }, { :user => user.id }
1146     end
1147     assert_redirected_to user_path(:display_name => friend.display_name)
1148     assert_match /You are already friends with/, flash[:warning]
1149     assert Friend.where(:user_id => user.id, :friend_user_id => friend.id).first
1150   end
1151
1152   def test_make_friend_with_referer
1153     # Get users to work with
1154     user = users(:normal_user)
1155     friend = users(:second_public_user)
1156
1157     # Check that the users aren't already friends
1158     assert_nil Friend.where(:user_id => user.id, :friend_user_id => friend.id).first
1159
1160     # The GET should preserve any referer
1161     get :make_friend, { :display_name => friend.display_name, :referer => "/test" }, { :user => user.id }
1162     assert_response :success
1163     assert_template :make_friend
1164     assert_select "form" do
1165       assert_select "input[type='hidden'][name='referer'][value='/test']", 1
1166       assert_select "input[type='submit']", 1
1167     end
1168     assert_nil Friend.where(:user_id => user.id, :friend_user_id => friend.id).first
1169
1170     # When logged in a POST should add the friendship and refer us
1171     assert_difference "ActionMailer::Base.deliveries.size", 1 do
1172       post :make_friend, { :display_name => friend.display_name, :referer => "/test" }, { :user => user.id }
1173     end
1174     assert_redirected_to "/test"
1175     assert_match /is now your friend/, flash[:notice]
1176     assert Friend.where(:user_id => user.id, :friend_user_id => friend.id).first
1177     email = ActionMailer::Base.deliveries.first
1178     assert_equal 1, email.to.count
1179     assert_equal friend.email, email.to.first
1180     ActionMailer::Base.deliveries.clear
1181   end
1182
1183   def test_make_friend_unkown_user
1184     # Should error when a bogus user is specified
1185     get :make_friend, { :display_name => "No Such User" }, { :user => users(:normal_user).id }
1186     assert_response :not_found
1187     assert_template :no_such_user
1188   end
1189
1190   def test_remove_friend
1191     # Get users to work with
1192     user = users(:normal_user)
1193     friend = users(:public_user)
1194     create(:friend, :user_id => user.id, :friend_user_id => friend.id)
1195
1196     # Check that the users are friends
1197     assert Friend.where(:user_id => user.id, :friend_user_id => friend.id).first
1198
1199     # When not logged in a GET should ask us to login
1200     get :remove_friend, :display_name => friend.display_name
1201     assert_redirected_to :controller => :user, :action => "login", :referer => remove_friend_path(:display_name => friend.display_name)
1202
1203     # When not logged in a POST should error
1204     post :remove_friend, :display_name => friend.display_name
1205     assert_response :forbidden
1206     assert Friend.where(:user_id => user.id, :friend_user_id => friend.id).first
1207
1208     # When logged in a GET should get a confirmation page
1209     get :remove_friend, { :display_name => friend.display_name }, { :user => user.id }
1210     assert_response :success
1211     assert_template :remove_friend
1212     assert_select "form" do
1213       assert_select "input[type='hidden'][name='referer']", 0
1214       assert_select "input[type='submit']", 1
1215     end
1216     assert Friend.where(:user_id => user.id, :friend_user_id => friend.id).first
1217
1218     # When logged in a POST should remove the friendship
1219     post :remove_friend, { :display_name => friend.display_name }, { :user => user.id }
1220     assert_redirected_to user_path(:display_name => friend.display_name)
1221     assert_match /was removed from your friends/, flash[:notice]
1222     assert_nil Friend.where(:user_id => user.id, :friend_user_id => friend.id).first
1223
1224     # A second POST should report that the friendship does not exist
1225     post :remove_friend, { :display_name => friend.display_name }, { :user => user.id }
1226     assert_redirected_to user_path(:display_name => friend.display_name)
1227     assert_match /is not one of your friends/, flash[:error]
1228     assert_nil Friend.where(:user_id => user.id, :friend_user_id => friend.id).first
1229   end
1230
1231   def test_remove_friend_with_referer
1232     # Get users to work with
1233     user = users(:normal_user)
1234     friend = users(:public_user)
1235     create(:friend, :user_id => user.id, :friend_user_id => friend.id)
1236
1237     # Check that the users are friends
1238     assert Friend.where(:user_id => user.id, :friend_user_id => friend.id).first
1239
1240     # The GET should preserve any referer
1241     get :remove_friend, { :display_name => friend.display_name, :referer => "/test" }, { :user => user.id }
1242     assert_response :success
1243     assert_template :remove_friend
1244     assert_select "form" do
1245       assert_select "input[type='hidden'][name='referer'][value='/test']", 1
1246       assert_select "input[type='submit']", 1
1247     end
1248     assert Friend.where(:user_id => user.id, :friend_user_id => friend.id).first
1249
1250     # When logged in a POST should remove the friendship and refer
1251     post :remove_friend, { :display_name => friend.display_name, :referer => "/test" }, { :user => user.id }
1252     assert_redirected_to "/test"
1253     assert_match /was removed from your friends/, flash[:notice]
1254     assert_nil Friend.where(:user_id => user.id, :friend_user_id => friend.id).first
1255   end
1256
1257   def test_remove_friend_unkown_user
1258     # Should error when a bogus user is specified
1259     get :remove_friend, { :display_name => "No Such User" }, { :user => users(:normal_user).id }
1260     assert_response :not_found
1261     assert_template :no_such_user
1262   end
1263
1264   def test_set_status
1265     # Try without logging in
1266     get :set_status, :display_name => users(:normal_user).display_name, :status => "suspended"
1267     assert_response :redirect
1268     assert_redirected_to :action => :login, :referer => set_status_user_path(:status => "suspended")
1269
1270     # Now try as a normal user
1271     get :set_status, { :display_name => users(:normal_user).display_name, :status => "suspended" }, { :user => users(:normal_user).id }
1272     assert_response :redirect
1273     assert_redirected_to :action => :view, :display_name => users(:normal_user).display_name
1274
1275     # Finally try as an administrator
1276     get :set_status, { :display_name => users(:normal_user).display_name, :status => "suspended" }, { :user => users(:administrator_user).id }
1277     assert_response :redirect
1278     assert_redirected_to :action => :view, :display_name => users(:normal_user).display_name
1279     assert_equal "suspended", User.find(users(:normal_user).id).status
1280   end
1281
1282   def test_delete
1283     # Try without logging in
1284     get :delete, :display_name => users(:normal_user).display_name, :status => "suspended"
1285     assert_response :redirect
1286     assert_redirected_to :action => :login, :referer => delete_user_path(:status => "suspended")
1287
1288     # Now try as a normal user
1289     get :delete, { :display_name => users(:normal_user).display_name, :status => "suspended" }, { :user => users(:normal_user).id }
1290     assert_response :redirect
1291     assert_redirected_to :action => :view, :display_name => users(:normal_user).display_name
1292
1293     # Finally try as an administrator
1294     get :delete, { :display_name => users(:normal_user).display_name, :status => "suspended" }, { :user => users(:administrator_user).id }
1295     assert_response :redirect
1296     assert_redirected_to :action => :view, :display_name => users(:normal_user).display_name
1297
1298     # Check that the user was deleted properly
1299     user = User.find(users(:normal_user).id)
1300     assert_equal "user_1", user.display_name
1301     assert_equal "", user.description
1302     assert_nil user.home_lat
1303     assert_nil user.home_lon
1304     assert_equal false, user.image.file?
1305     assert_equal false, user.email_valid
1306     assert_nil user.new_email
1307     assert_nil user.auth_provider
1308     assert_nil user.auth_uid
1309     assert_equal "deleted", user.status
1310   end
1311
1312   def test_list_get
1313     # Shouldn't work when not logged in
1314     get :list
1315     assert_response :redirect
1316     assert_redirected_to :action => :login, :referer => users_path
1317
1318     session[:user] = users(:normal_user).id
1319
1320     # Shouldn't work when logged in as a normal user
1321     get :list
1322     assert_response :redirect
1323     assert_redirected_to :action => :login, :referer => users_path
1324
1325     session[:user] = users(:moderator_user).id
1326
1327     # Shouldn't work when logged in as a moderator
1328     get :list
1329     assert_response :redirect
1330     assert_redirected_to :action => :login, :referer => users_path
1331
1332     session[:user] = users(:administrator_user).id
1333
1334     # Should work when logged in as an administrator
1335     get :list
1336     assert_response :success
1337     assert_template :list
1338     assert_select "table#user_list tr", :count => User.count + 1
1339
1340     # Should be able to limit by status
1341     get :list, :status => "suspended"
1342     assert_response :success
1343     assert_template :list
1344     assert_select "table#user_list tr", :count => User.where(:status => "suspended").count + 1
1345
1346     # Should be able to limit by IP address
1347     get :list, :ip => "1.2.3.4"
1348     assert_response :success
1349     assert_template :list
1350     assert_select "table#user_list tr", :count => User.where(:creation_ip => "1.2.3.4").count + 1
1351   end
1352
1353   def test_list_get_paginated
1354     1.upto(100).each do |n|
1355       User.create(:display_name => "extra_#{n}",
1356                   :email => "extra#{n}@example.com",
1357                   :pass_crypt => "extraextra")
1358     end
1359
1360     session[:user] = users(:administrator_user).id
1361
1362     get :list
1363     assert_response :success
1364     assert_template :list
1365     assert_select "table#user_list tr", :count => 51
1366
1367     get :list, :page => 2
1368     assert_response :success
1369     assert_template :list
1370     assert_select "table#user_list tr", :count => 51
1371
1372     get :list, :page => 3
1373     assert_response :success
1374     assert_template :list
1375     assert_select "table#user_list tr", :count => 25
1376   end
1377
1378   def test_list_post_confirm
1379     inactive_user = users(:inactive_user)
1380     suspended_user = users(:suspended_user)
1381
1382     # Shouldn't work when not logged in
1383     assert_no_difference "User.active.count" do
1384       post :list, :confirm => 1, :user => { inactive_user.id => 1, suspended_user.id => 1 }
1385     end
1386     assert_response :redirect
1387     assert_redirected_to :action => :login, :referer => users_path(:confirm => 1, :user => { inactive_user.id => 1, suspended_user.id => 1 })
1388     assert_equal "pending", inactive_user.reload.status
1389     assert_equal "suspended", suspended_user.reload.status
1390
1391     session[:user] = users(:normal_user).id
1392
1393     # Shouldn't work when logged in as a normal user
1394     assert_no_difference "User.active.count" do
1395       post :list, :confirm => 1, :user => { inactive_user.id => 1, suspended_user.id => 1 }
1396     end
1397     assert_response :redirect
1398     assert_redirected_to :action => :login, :referer => users_path(:confirm => 1, :user => { inactive_user.id => 1, suspended_user.id => 1 })
1399     assert_equal "pending", inactive_user.reload.status
1400     assert_equal "suspended", suspended_user.reload.status
1401
1402     session[:user] = users(:moderator_user).id
1403
1404     # Shouldn't work when logged in as a moderator
1405     assert_no_difference "User.active.count" do
1406       post :list, :confirm => 1, :user => { inactive_user.id => 1, suspended_user.id => 1 }
1407     end
1408     assert_response :redirect
1409     assert_redirected_to :action => :login, :referer => users_path(:confirm => 1, :user => { inactive_user.id => 1, suspended_user.id => 1 })
1410     assert_equal "pending", inactive_user.reload.status
1411     assert_equal "suspended", suspended_user.reload.status
1412
1413     session[:user] = users(:administrator_user).id
1414
1415     # Should work when logged in as an administrator
1416     assert_difference "User.active.count", 2 do
1417       post :list, :confirm => 1, :user => { inactive_user.id => 1, suspended_user.id => 1 }
1418     end
1419     assert_response :redirect
1420     assert_redirected_to :action => :list
1421     assert_equal "confirmed", inactive_user.reload.status
1422     assert_equal "confirmed", suspended_user.reload.status
1423   end
1424
1425   def test_list_post_hide
1426     normal_user = users(:normal_user)
1427     confirmed_user = users(:confirmed_user)
1428
1429     # Shouldn't work when not logged in
1430     assert_no_difference "User.active.count" do
1431       post :list, :hide => 1, :user => { normal_user.id => 1, confirmed_user.id => 1 }
1432     end
1433     assert_response :redirect
1434     assert_redirected_to :action => :login, :referer => users_path(:hide => 1, :user => { normal_user.id => 1, confirmed_user.id => 1 })
1435     assert_equal "active", normal_user.reload.status
1436     assert_equal "confirmed", confirmed_user.reload.status
1437
1438     session[:user] = users(:normal_user).id
1439
1440     # Shouldn't work when logged in as a normal user
1441     assert_no_difference "User.active.count" do
1442       post :list, :hide => 1, :user => { normal_user.id => 1, confirmed_user.id => 1 }
1443     end
1444     assert_response :redirect
1445     assert_redirected_to :action => :login, :referer => users_path(:hide => 1, :user => { normal_user.id => 1, confirmed_user.id => 1 })
1446     assert_equal "active", normal_user.reload.status
1447     assert_equal "confirmed", confirmed_user.reload.status
1448
1449     session[:user] = users(:moderator_user).id
1450
1451     # Shouldn't work when logged in as a moderator
1452     assert_no_difference "User.active.count" do
1453       post :list, :hide => 1, :user => { normal_user.id => 1, confirmed_user.id => 1 }
1454     end
1455     assert_response :redirect
1456     assert_redirected_to :action => :login, :referer => users_path(:hide => 1, :user => { normal_user.id => 1, confirmed_user.id => 1 })
1457     assert_equal "active", normal_user.reload.status
1458     assert_equal "confirmed", confirmed_user.reload.status
1459
1460     session[:user] = users(:administrator_user).id
1461
1462     # Should work when logged in as an administrator
1463     assert_difference "User.active.count", -2 do
1464       post :list, :hide => 1, :user => { normal_user.id => 1, confirmed_user.id => 1 }
1465     end
1466     assert_response :redirect
1467     assert_redirected_to :action => :list
1468     assert_equal "deleted", normal_user.reload.status
1469     assert_equal "deleted", confirmed_user.reload.status
1470   end
1471
1472   private
1473
1474   def new_user
1475     user = User.new
1476     user.status = "pending"
1477     user.display_name = "new_tester"
1478     user.email = "newtester@osm.org"
1479     user.email_confirmation = "newtester@osm.org"
1480     user.pass_crypt = "testtest"
1481     user.pass_crypt_confirmation = "testtest"
1482     user
1483   end
1484 end