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