test/controllers/user_controller_test.rb

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