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