test/controllers/users_controller_test.rb

   1 require "test_helper"
   2
   3 class UsersControllerTest < ActionDispatch::IntegrationTest
   4   ##
   5   # test all routes which lead to this controller
   6   def test_routes
   7     assert_routing(
   8       { :path => "/user/new", :method => :get },
   9       { :controller => "users", :action => "new" }
  10     )
  11
  12     assert_routing(
  13       { :path => "/user/new", :method => :post },
  14       { :controller => "users", :action => "create" }
  15     )
  16
  17     assert_routing(
  18       { :path => "/user/terms", :method => :get },
  19       { :controller => "users", :action => "terms" }
  20     )
  21
  22     assert_routing(
  23       { :path => "/user/save", :method => :post },
  24       { :controller => "users", :action => "save" }
  25     )
  26
  27     assert_routing(
  28       { :path => "/user/go_public", :method => :post },
  29       { :controller => "users", :action => "go_public" }
  30     )
  31
  32     assert_routing(
  33       { :path => "/user/suspended", :method => :get },
  34       { :controller => "users", :action => "suspended" }
  35     )
  36
  37     assert_routing(
  38       { :path => "/user/username", :method => :get },
  39       { :controller => "users", :action => "show", :display_name => "username" }
  40     )
  41
  42     assert_routing(
  43       { :path => "/user/username/set_status", :method => :post },
  44       { :controller => "users", :action => "set_status", :display_name => "username" }
  45     )
  46     assert_routing(
  47       { :path => "/user/username", :method => :delete },
  48       { :controller => "users", :action => "destroy", :display_name => "username" }
  49     )
  50
  51     assert_routing(
  52       { :path => "/users", :method => :get },
  53       { :controller => "users", :action => "index" }
  54     )
  55     assert_routing(
  56       { :path => "/users", :method => :post },
  57       { :controller => "users", :action => "index" }
  58     )
  59     assert_routing(
  60       { :path => "/users/status", :method => :get },
  61       { :controller => "users", :action => "index", :status => "status" }
  62     )
  63     assert_routing(
  64       { :path => "/users/status", :method => :post },
  65       { :controller => "users", :action => "index", :status => "status" }
  66     )
  67   end
  68
  69   # The user creation page loads
  70   def test_new_view
  71     get user_new_path
  72     assert_redirected_to user_new_path(:cookie_test => "true")
  73
  74     get user_new_path, :params => { :cookie_test => "true" }
  75     assert_response :success
  76
  77     assert_select "html", :count => 1 do
  78       assert_select "head", :count => 1 do
  79         assert_select "title", :text => /Sign Up/, :count => 1
  80       end
  81       assert_select "body", :count => 1 do
  82         assert_select "div#content", :count => 1 do
  83           assert_select "form[action='/user/new'][method='post']", :count => 1 do
  84             assert_select "input[id='user_email']", :count => 1
  85             assert_select "input[id='user_email_confirmation']", :count => 1
  86             assert_select "input[id='user_display_name']", :count => 1
  87             assert_select "input[id='user_pass_crypt'][type='password']", :count => 1
  88             assert_select "input[id='user_pass_crypt_confirmation'][type='password']", :count => 1
  89             assert_select "input[type='submit'][value='Sign Up']", :count => 1
  90           end
  91         end
  92       end
  93     end
  94   end
  95
  96   def test_new_view_logged_in
  97     session_for(create(:user))
  98
  99     get user_new_path
 100     assert_redirected_to root_path
 101
 102     get user_new_path, :params => { :referer => "/test" }
 103     assert_redirected_to "/test"
 104   end
 105
 106   def test_new_success
 107     user = build(:user, :pending)
 108
 109     assert_no_difference "User.count" do
 110       assert_no_difference "ActionMailer::Base.deliveries.size" do
 111         perform_enqueued_jobs do
 112           post user_new_path, :params => { :user => user.attributes }
 113         end
 114       end
 115     end
 116
 117     assert_difference "User.count", 1 do
 118       assert_difference "ActionMailer::Base.deliveries.size", 1 do
 119         perform_enqueued_jobs do
 120           post user_save_path, :params => { :read_ct => 1, :read_tou => 1 }
 121         end
 122       end
 123     end
 124
 125     # Check the e-mail
 126     register_email = ActionMailer::Base.deliveries.first
 127
 128     assert_equal register_email.to[0], user.email
 129     assert_match(/#{@url}/, register_email.body.to_s)
 130
 131     # Check the page
 132     assert_redirected_to :controller => :confirmations, :action => :confirm, :display_name => user.display_name
 133
 134     ActionMailer::Base.deliveries.clear
 135   end
 136
 137   def test_new_duplicate_email
 138     user = build(:user, :pending)
 139     create(:user, :email => user.email)
 140
 141     assert_no_difference "User.count" do
 142       assert_no_difference "ActionMailer::Base.deliveries.size" do
 143         perform_enqueued_jobs do
 144           post user_new_path, :params => { :user => user.attributes }
 145         end
 146       end
 147     end
 148
 149     assert_response :success
 150     assert_template "new"
 151     assert_select "form > div > input.is-invalid#user_email"
 152   end
 153
 154   def test_save_duplicate_email
 155     user = build(:user, :pending)
 156
 157     # Set up our user as being half-way through registration
 158     assert_no_difference "User.count" do
 159       assert_no_difference "ActionMailer::Base.deliveries.size" do
 160         perform_enqueued_jobs do
 161           post user_new_path, :params => { :user => user.attributes }
 162         end
 163       end
 164     end
 165
 166     # Now create another user with that email
 167     create(:user, :email => user.email)
 168
 169     # Check that the second half of registration fails
 170     assert_no_difference "User.count" do
 171       assert_no_difference "ActionMailer::Base.deliveries.size" do
 172         perform_enqueued_jobs do
 173           post user_save_path, :params => { :read_ct => 1, :read_tou => 1 }
 174         end
 175       end
 176     end
 177
 178     assert_response :success
 179     assert_template "new"
 180     assert_select "form > div > input.is-invalid#user_email"
 181   end
 182
 183   def test_save_duplicate_email_uppercase
 184     user = build(:user, :pending)
 185
 186     # Set up our user as being half-way through registration
 187     assert_no_difference "User.count" do
 188       assert_no_difference "ActionMailer::Base.deliveries.size" do
 189         perform_enqueued_jobs do
 190           post user_new_path, :params => { :user => user.attributes }
 191         end
 192       end
 193     end
 194
 195     # Now create another user with that email, but uppercased
 196     create(:user, :email => user.email.upcase)
 197
 198     # Check that the second half of registration fails
 199     assert_no_difference "User.count" do
 200       assert_no_difference "ActionMailer::Base.deliveries.size" do
 201         perform_enqueued_jobs do
 202           post user_save_path, :params => { :read_ct => 1, :read_tou => 1 }
 203         end
 204       end
 205     end
 206
 207     assert_response :success
 208     assert_template "new"
 209     assert_select "form > div > input.is-invalid#user_email"
 210   end
 211
 212   def test_save_duplicate_name
 213     user = build(:user, :pending)
 214
 215     # Set up our user as being half-way through registration
 216     assert_no_difference "User.count" do
 217       assert_no_difference "ActionMailer::Base.deliveries.size" do
 218         perform_enqueued_jobs do
 219           post user_new_path, :params => { :user => user.attributes }
 220         end
 221       end
 222     end
 223
 224     # Now create another user with that display name
 225     create(:user, :display_name => user.display_name)
 226
 227     # Check that the second half of registration fails
 228     assert_no_difference "User.count" do
 229       assert_no_difference "ActionMailer::Base.deliveries.size" do
 230         perform_enqueued_jobs do
 231           post user_save_path, :params => { :read_ct => 1, :read_tou => 1 }
 232         end
 233       end
 234     end
 235
 236     assert_response :success
 237     assert_template "new"
 238     assert_select "form > div > input.is-invalid#user_display_name"
 239   end
 240
 241   def test_save_duplicate_name_uppercase
 242     user = build(:user, :pending)
 243
 244     # Set up our user as being half-way through registration
 245     assert_no_difference "User.count" do
 246       assert_no_difference "ActionMailer::Base.deliveries.size" do
 247         perform_enqueued_jobs do
 248           post user_new_path, :params => { :user => user.attributes }
 249         end
 250       end
 251     end
 252
 253     # Now create another user with that display_name, but uppercased
 254     create(:user, :display_name => user.display_name.upcase)
 255
 256     # Check that the second half of registration fails
 257     assert_no_difference "User.count" do
 258       assert_no_difference "ActionMailer::Base.deliveries.size" do
 259         perform_enqueued_jobs do
 260           post user_save_path, :params => { :read_ct => 1, :read_tou => 1 }
 261         end
 262       end
 263     end
 264
 265     assert_response :success
 266     assert_template "new"
 267     assert_select "form > div > input.is-invalid#user_display_name"
 268   end
 269
 270   def test_save_blocked_domain
 271     user = build(:user, :pending, :email => "user@example.net")
 272
 273     # Set up our user as being half-way through registration
 274     assert_no_difference "User.count" do
 275       assert_no_difference "ActionMailer::Base.deliveries.size" do
 276         perform_enqueued_jobs do
 277           post user_new_path, :params => { :user => user.attributes }
 278         end
 279       end
 280     end
 281
 282     # Now block that domain
 283     create(:acl, :domain => "example.net", :k => "no_account_creation")
 284
 285     # Check that the second half of registration fails
 286     assert_no_difference "User.count" do
 287       assert_no_difference "ActionMailer::Base.deliveries.size" do
 288         perform_enqueued_jobs do
 289           post user_save_path, :params => { :read_ct => 1, :read_tou => 1 }
 290         end
 291       end
 292     end
 293
 294     assert_response :success
 295     assert_template "blocked"
 296   end
 297
 298   def test_save_referer_params
 299     user = build(:user, :pending)
 300
 301     # Set up our user as being half-way through registration
 302     assert_no_difference "User.count" do
 303       assert_no_difference "ActionMailer::Base.deliveries.size" do
 304         perform_enqueued_jobs do
 305           post user_new_path, :params => { :user => user.attributes, :referer => "/edit?editor=id#map=1/2/3" }
 306         end
 307       end
 308     end
 309
 310     assert_difference "User.count", 1 do
 311       assert_difference "ActionMailer::Base.deliveries.size", 1 do
 312         post user_save_path, :params => { :read_ct => 1, :read_tou => 1 }
 313         assert_enqueued_with :job => ActionMailer::MailDeliveryJob,
 314                              :args => proc { |args| args[3][:args][2] == welcome_path(:editor => "id", :zoom => 1, :lat => 2, :lon => 3) }
 315         perform_enqueued_jobs
 316       end
 317     end
 318
 319     ActionMailer::Base.deliveries.clear
 320   end
 321
 322   def test_terms_new_user
 323     user = build(:user, :pending)
 324
 325     # Set up our user as being half-way through registration
 326     assert_no_difference "User.count" do
 327       assert_no_difference "ActionMailer::Base.deliveries.size" do
 328         perform_enqueued_jobs do
 329           post user_new_path, :params => { :user => user.attributes }
 330         end
 331       end
 332     end
 333
 334     get user_terms_path
 335
 336     assert_response :success
 337     assert_template :terms
 338   end
 339
 340   def test_terms_agreed
 341     user = create(:user, :terms_seen => true, :terms_agreed => Date.yesterday)
 342
 343     session_for(user)
 344
 345     get user_terms_path
 346     assert_redirected_to edit_account_path
 347   end
 348
 349   def test_terms_not_seen_without_referer
 350     user = create(:user, :terms_seen => false, :terms_agreed => nil)
 351
 352     session_for(user)
 353
 354     get user_terms_path
 355     assert_response :success
 356     assert_template :terms
 357
 358     post user_save_path, :params => { :user => { :consider_pd => true }, :read_ct => 1, :read_tou => 1 }
 359     assert_redirected_to edit_account_path
 360     assert_equal "Thanks for accepting the new contributor terms!", flash[:notice]
 361
 362     user.reload
 363
 364     assert user.consider_pd
 365     assert_not_nil user.terms_agreed
 366     assert user.terms_seen
 367   end
 368
 369   def test_terms_not_seen_with_referer
 370     user = create(:user, :terms_seen => false, :terms_agreed => nil)
 371
 372     session_for(user)
 373
 374     get user_terms_path, :params => { :referer => "/test" }
 375     assert_response :success
 376     assert_template :terms
 377
 378     post user_save_path, :params => { :user => { :consider_pd => true }, :referer => "/test", :read_ct => 1, :read_tou => 1 }
 379     assert_redirected_to "/test"
 380     assert_equal "Thanks for accepting the new contributor terms!", flash[:notice]
 381
 382     user.reload
 383
 384     assert user.consider_pd
 385     assert_not_nil user.terms_agreed
 386     assert user.terms_seen
 387   end
 388
 389   # Check that if you haven't seen the terms, and make a request that requires authentication,
 390   # that your request is redirected to view the terms
 391   def test_terms_not_seen_redirection
 392     user = create(:user, :terms_seen => false, :terms_agreed => nil)
 393     session_for(user)
 394
 395     get edit_account_path
 396     assert_redirected_to :controller => :users, :action => :terms, :referer => "/account/edit"
 397   end
 398
 399   def test_terms_not_logged_in
 400     get user_terms_path
 401
 402     assert_redirected_to login_path(:referer => "/user/terms")
 403   end
 404
 405   def test_go_public
 406     user = create(:user, :data_public => false)
 407     session_for(user)
 408
 409     post user_go_public_path
 410
 411     assert_redirected_to edit_account_path
 412     assert User.find(user.id).data_public
 413   end
 414
 415   # Check that the user account page will display and contains some relevant
 416   # information for the user
 417   def test_show
 418     # Test a non-existent user
 419     get user_path("unknown")
 420     assert_response :not_found
 421
 422     # Test a normal user
 423     user = create(:user)
 424
 425     get user_path(user)
 426     assert_response :success
 427     assert_select "div.content-heading" do
 428       assert_select "a[href^='/user/#{ERB::Util.u(user.display_name)}/history']", 1
 429       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/traces']", 1
 430       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/diary']", 1
 431       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/diary/comments']", 1
 432       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/account']", 0
 433       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/blocks']", 0
 434       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/blocks_by']", 0
 435       assert_select "a[href='/blocks/new/#{ERB::Util.u(user.display_name)}']", 0
 436     end
 437
 438     # Friends shouldn't be visible as we're not logged in
 439     assert_select "div#friends-container", :count => 0
 440
 441     # Test a user who has been blocked
 442     blocked_user = create(:user)
 443     create(:user_block, :user => blocked_user)
 444     get user_path(blocked_user)
 445     assert_response :success
 446     assert_select "div.content-heading" do
 447       assert_select "a[href^='/user/#{ERB::Util.u(blocked_user.display_name)}/history']", 1
 448       assert_select "a[href='/user/#{ERB::Util.u(blocked_user.display_name)}/traces']", 1
 449       assert_select "a[href='/user/#{ERB::Util.u(blocked_user.display_name)}/diary']", 1
 450       assert_select "a[href='/user/#{ERB::Util.u(blocked_user.display_name)}/diary/comments']", 1
 451       assert_select "a[href='/user/#{ERB::Util.u(blocked_user.display_name)}/account']", 0
 452       assert_select "a[href='/user/#{ERB::Util.u(blocked_user.display_name)}/blocks']", 1
 453       assert_select "a[href='/user/#{ERB::Util.u(blocked_user.display_name)}/blocks_by']", 0
 454       assert_select "a[href='/blocks/new/#{ERB::Util.u(blocked_user.display_name)}']", 0
 455     end
 456
 457     # Test a moderator who has applied blocks
 458     moderator_user = create(:moderator_user)
 459     create(:user_block, :creator => moderator_user)
 460     get user_path(moderator_user)
 461     assert_response :success
 462     assert_select "div.content-heading" do
 463       assert_select "a[href^='/user/#{ERB::Util.u(moderator_user.display_name)}/history']", 1
 464       assert_select "a[href='/user/#{ERB::Util.u(moderator_user.display_name)}/traces']", 1
 465       assert_select "a[href='/user/#{ERB::Util.u(moderator_user.display_name)}/diary']", 1
 466       assert_select "a[href='/user/#{ERB::Util.u(moderator_user.display_name)}/diary/comments']", 1
 467       assert_select "a[href='/user/#{ERB::Util.u(moderator_user.display_name)}/account']", 0
 468       assert_select "a[href='/user/#{ERB::Util.u(moderator_user.display_name)}/blocks']", 0
 469       assert_select "a[href='/user/#{ERB::Util.u(moderator_user.display_name)}/blocks_by']", 1
 470       assert_select "a[href='/blocks/new/#{ERB::Util.u(moderator_user.display_name)}']", 0
 471     end
 472
 473     # Login as a normal user
 474     session_for(user)
 475
 476     # Test the normal user
 477     get user_path(user)
 478     assert_response :success
 479     assert_select "div.content-heading" do
 480       assert_select "a[href^='/user/#{ERB::Util.u(user.display_name)}/history']", 1
 481       assert_select "a[href='/traces/mine']", 1
 482       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/diary']", 1
 483       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/diary/comments']", 1
 484       assert_select "a[href='/account/edit']", 1
 485       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/blocks']", 0
 486       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/blocks_by']", 0
 487       assert_select "a[href='/blocks/new/#{ERB::Util.u(user.display_name)}']", 0
 488       assert_select "a[href='/api/0.6/user/#{ERB::Util.u(user.id)}']", 0
 489     end
 490
 491     # Login as a moderator
 492     session_for(create(:moderator_user))
 493
 494     # Test the normal user
 495     get user_path(user)
 496     assert_response :success
 497     assert_select "div.content-heading" do
 498       assert_select "a[href^='/user/#{ERB::Util.u(user.display_name)}/history']", 1
 499       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/traces']", 1
 500       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/diary']", 1
 501       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/diary/comments']", 1
 502       assert_select "a[href='/account/edit']", 0
 503       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/blocks']", 0
 504       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/blocks_by']", 0
 505       assert_select "a[href='/blocks/new/#{ERB::Util.u(user.display_name)}']", 1
 506       assert_select "a[href='/api/0.6/user/#{ERB::Util.u(user.id)}']", 1
 507     end
 508   end
 509
 510   # Test whether information about contributor terms is shown for users who haven't agreed
 511   def test_terms_not_agreed
 512     agreed_user = create(:user, :terms_agreed => 3.days.ago)
 513     seen_user = create(:user, :terms_seen => true, :terms_agreed => nil)
 514     not_seen_user = create(:user, :terms_seen => false, :terms_agreed => nil)
 515
 516     get user_path(agreed_user)
 517     assert_response :success
 518     assert_select "div.content-heading" do
 519       assert_select "dt", :count => 0, :text => /Contributor terms/
 520     end
 521
 522     get user_path(seen_user)
 523     assert_response :success
 524     assert_select "div.content-heading" do
 525       assert_select "dt", :count => 1, :text => /Contributor terms/
 526       assert_select "dd", /Declined/
 527     end
 528
 529     get user_path(not_seen_user)
 530     assert_response :success
 531     assert_select "div.content-heading" do
 532       assert_select "dt", :count => 1, :text => /Contributor terms/
 533       assert_select "dd", /Undecided/
 534     end
 535   end
 536
 537   def test_set_status
 538     user = create(:user)
 539
 540     # Try without logging in
 541     post set_status_user_path(user), :params => { :event => "confirm" }
 542     assert_response :forbidden
 543
 544     # Now try as a normal user
 545     session_for(user)
 546     post set_status_user_path(user), :params => { :event => "confirm" }
 547     assert_redirected_to :controller => :errors, :action => :forbidden
 548
 549     # Finally try as an administrator
 550     session_for(create(:administrator_user))
 551     post set_status_user_path(user), :params => { :event => "confirm" }
 552     assert_redirected_to :action => :show, :display_name => user.display_name
 553     assert_equal "confirmed", User.find(user.id).status
 554   end
 555
 556   def test_destroy
 557     user = create(:user, :home_lat => 12.1, :home_lon => 12.1, :description => "test")
 558
 559     # Try without logging in
 560     delete user_path(user)
 561     assert_response :forbidden
 562
 563     # Now try as a normal user
 564     session_for(user)
 565     delete user_path(user)
 566     assert_redirected_to :controller => :errors, :action => :forbidden
 567
 568     # Finally try as an administrator
 569     session_for(create(:administrator_user))
 570     delete user_path(user)
 571     assert_redirected_to :action => :show, :display_name => user.display_name
 572
 573     # Check that the user was deleted properly
 574     user.reload
 575     assert_equal "user_#{user.id}", user.display_name
 576     assert_equal "", user.description
 577     assert_nil user.home_lat
 578     assert_nil user.home_lon
 579     assert_not user.avatar.attached?
 580     assert_not user.email_valid
 581     assert_nil user.new_email
 582     assert_nil user.auth_provider
 583     assert_nil user.auth_uid
 584     assert_equal "deleted", user.status
 585   end
 586
 587   def test_index_get
 588     user = create(:user)
 589     moderator_user = create(:moderator_user)
 590     administrator_user = create(:administrator_user)
 591     _suspended_user = create(:user, :suspended)
 592     _ip_user = create(:user, :creation_ip => "1.2.3.4")
 593
 594     # There are now 7 users - the five above, plus two extra "granters" for the
 595     # moderator_user and administrator_user
 596     assert_equal 7, User.count
 597
 598     # Shouldn't work when not logged in
 599     get users_path
 600     assert_redirected_to login_path(:referer => users_path)
 601
 602     session_for(user)
 603
 604     # Shouldn't work when logged in as a normal user
 605     get users_path
 606     assert_redirected_to :controller => :errors, :action => :forbidden
 607
 608     session_for(moderator_user)
 609
 610     # Shouldn't work when logged in as a moderator
 611     get users_path
 612     assert_redirected_to :controller => :errors, :action => :forbidden
 613
 614     session_for(administrator_user)
 615
 616     # Note there is a header row, so all row counts are users + 1
 617     # Should work when logged in as an administrator
 618     get users_path
 619     assert_response :success
 620     assert_template :index
 621     assert_select "table#user_list tbody tr", :count => 7
 622
 623     # Should be able to limit by status
 624     get users_path, :params => { :status => "suspended" }
 625     assert_response :success
 626     assert_template :index
 627     assert_select "table#user_list tbody tr", :count => 1
 628
 629     # Should be able to limit by IP address
 630     get users_path, :params => { :ip => "1.2.3.4" }
 631     assert_response :success
 632     assert_template :index
 633     assert_select "table#user_list tbody tr", :count => 1
 634   end
 635
 636   def test_index_get_paginated
 637     1.upto(100).each do |n|
 638       User.create(:display_name => "extra_#{n}",
 639                   :email => "extra#{n}@example.com",
 640                   :pass_crypt => "extraextra")
 641     end
 642
 643     session_for(create(:administrator_user))
 644
 645     # 100 examples, an administrator, and a granter for the admin.
 646     assert_equal 102, User.count
 647
 648     get users_path
 649     assert_response :success
 650     assert_template :index
 651     assert_select "table#user_list tbody tr", :count => 50
 652
 653     get users_path, :params => { :page => 2 }
 654     assert_response :success
 655     assert_template :index
 656     assert_select "table#user_list tbody tr", :count => 50
 657
 658     get users_path, :params => { :page => 3 }
 659     assert_response :success
 660     assert_template :index
 661     assert_select "table#user_list tbody tr", :count => 2
 662   end
 663
 664   def test_index_post_confirm
 665     inactive_user = create(:user, :pending)
 666     suspended_user = create(:user, :suspended)
 667
 668     # Shouldn't work when not logged in
 669     assert_no_difference "User.active.count" do
 670       post users_path, :params => { :confirm => 1, :user => { inactive_user.id => 1, suspended_user.id => 1 } }
 671     end
 672     assert_response :forbidden
 673
 674     assert_equal "pending", inactive_user.reload.status
 675     assert_equal "suspended", suspended_user.reload.status
 676
 677     session_for(create(:user))
 678
 679     # Shouldn't work when logged in as a normal user
 680     assert_no_difference "User.active.count" do
 681       post users_path, :params => { :confirm => 1, :user => { inactive_user.id => 1, suspended_user.id => 1 } }
 682     end
 683     assert_redirected_to :controller => :errors, :action => :forbidden
 684     assert_equal "pending", inactive_user.reload.status
 685     assert_equal "suspended", suspended_user.reload.status
 686
 687     session_for(create(:moderator_user))
 688
 689     # Shouldn't work when logged in as a moderator
 690     assert_no_difference "User.active.count" do
 691       post users_path, :params => { :confirm => 1, :user => { inactive_user.id => 1, suspended_user.id => 1 } }
 692     end
 693     assert_redirected_to :controller => :errors, :action => :forbidden
 694     assert_equal "pending", inactive_user.reload.status
 695     assert_equal "suspended", suspended_user.reload.status
 696
 697     session_for(create(:administrator_user))
 698
 699     # Should work when logged in as an administrator
 700     assert_difference "User.active.count", 2 do
 701       post users_path, :params => { :confirm => 1, :user => { inactive_user.id => 1, suspended_user.id => 1 } }
 702     end
 703     assert_redirected_to :action => :index
 704     assert_equal "confirmed", inactive_user.reload.status
 705     assert_equal "confirmed", suspended_user.reload.status
 706   end
 707
 708   def test_index_post_hide
 709     normal_user = create(:user)
 710     confirmed_user = create(:user, :confirmed)
 711
 712     # Shouldn't work when not logged in
 713     assert_no_difference "User.active.count" do
 714       post users_path, :params => { :hide => 1, :user => { normal_user.id => 1, confirmed_user.id => 1 } }
 715     end
 716     assert_response :forbidden
 717
 718     assert_equal "active", normal_user.reload.status
 719     assert_equal "confirmed", confirmed_user.reload.status
 720
 721     session_for(create(:user))
 722
 723     # Shouldn't work when logged in as a normal user
 724     assert_no_difference "User.active.count" do
 725       post users_path, :params => { :hide => 1, :user => { normal_user.id => 1, confirmed_user.id => 1 } }
 726     end
 727     assert_redirected_to :controller => :errors, :action => :forbidden
 728     assert_equal "active", normal_user.reload.status
 729     assert_equal "confirmed", confirmed_user.reload.status
 730
 731     session_for(create(:moderator_user))
 732
 733     # Shouldn't work when logged in as a moderator
 734     assert_no_difference "User.active.count" do
 735       post users_path, :params => { :hide => 1, :user => { normal_user.id => 1, confirmed_user.id => 1 } }
 736     end
 737     assert_redirected_to :controller => :errors, :action => :forbidden
 738     assert_equal "active", normal_user.reload.status
 739     assert_equal "confirmed", confirmed_user.reload.status
 740
 741     session_for(create(:administrator_user))
 742
 743     # Should work when logged in as an administrator
 744     assert_difference "User.active.count", -2 do
 745       post users_path, :params => { :hide => 1, :user => { normal_user.id => 1, confirmed_user.id => 1 } }
 746     end
 747     assert_redirected_to :action => :index
 748     assert_equal "deleted", normal_user.reload.status
 749     assert_equal "deleted", confirmed_user.reload.status
 750   end
 751
 752   def test_auth_failure_callback
 753     get auth_failure_path
 754     assert_redirected_to login_path
 755
 756     get auth_failure_path, :params => { :origin => "/" }
 757     assert_redirected_to root_path
 758
 759     get auth_failure_path, :params => { :origin => "http://www.google.com" }
 760     assert_redirected_to login_path
 761   end
 762 end