test/controllers/user_controller_test.rb

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