test/controllers/user_controller_test.rb

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