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_login
 410     user = create(:user)
 411
 412     get login_path
 413     assert_response :redirect
 414     assert_redirected_to login_path(:cookie_test => true)
 415     follow_redirect!
 416     assert_response :success
 417     assert_template "login"
 418
 419     get login_path, :params => { :username => user.display_name, :password => "test" }
 420     assert_response :success
 421     assert_template "login"
 422
 423     post login_path, :params => { :username => user.display_name, :password => "test" }
 424     assert_response :redirect
 425     assert_redirected_to root_path
 426   end
 427
 428   def test_logout_without_referer
 429     post logout_path
 430     assert_response :redirect
 431     assert_redirected_to root_path
 432   end
 433
 434   def test_logout_with_referer
 435     post logout_path, :params => { :referer => "/test" }
 436     assert_response :redirect
 437     assert_redirected_to "/test"
 438   end
 439
 440   def test_logout_fallback_without_referer
 441     get logout_path
 442     assert_response :success
 443     assert_template :logout
 444     assert_select "input[name=referer]:not([value])"
 445   end
 446
 447   def test_logout_fallback_with_referer
 448     get logout_path, :params => { :referer => "/test" }
 449     assert_response :success
 450     assert_template :logout
 451     assert_select "input[name=referer][value=?]", "/test"
 452   end
 453
 454   def test_logout_removes_session_token
 455     user = build(:user, :pending)
 456     post user_new_path, :params => { :user => user.attributes }
 457     post user_save_path, :params => { :read_ct => 1, :read_tou => 1 }
 458
 459     assert_difference "User.find_by(:email => user.email).tokens.count", -1 do
 460       post logout_path
 461     end
 462     assert_response :redirect
 463     assert_redirected_to root_path
 464   end
 465
 466   def test_confirm_get
 467     user = build(:user, :pending)
 468     post user_new_path, :params => { :user => user.attributes }
 469     post user_save_path, :params => { :read_ct => 1, :read_tou => 1 }
 470     confirm_string = User.find_by(:email => user.email).tokens.create.token
 471
 472     get user_confirm_path, :params => { :display_name => user.display_name, :confirm_string => confirm_string }
 473     assert_response :success
 474     assert_template :confirm
 475   end
 476
 477   def test_confirm_get_already_confirmed
 478     user = build(:user, :pending)
 479     stub_gravatar_request(user.email)
 480     post user_new_path, :params => { :user => user.attributes }
 481     post user_save_path, :params => { :read_ct => 1, :read_tou => 1 }
 482     confirm_string = User.find_by(:email => user.email).tokens.create.token
 483
 484     # Get the confirmation page
 485     get user_confirm_path, :params => { :display_name => user.display_name, :confirm_string => confirm_string }
 486     assert_response :success
 487     assert_template :confirm
 488
 489     # Confirm the user
 490     post user_confirm_path, :params => { :display_name => user.display_name, :confirm_string => confirm_string }
 491     assert_redirected_to welcome_path
 492
 493     # Now try to get the confirmation page again
 494     get user_confirm_path, :params => { :display_name => user.display_name, :confirm_string => confirm_string }
 495     assert_response :redirect
 496     assert_redirected_to root_path
 497   end
 498
 499   def test_confirm_success_no_token_no_referer
 500     user = build(:user, :pending)
 501     stub_gravatar_request(user.email)
 502     post user_new_path, :params => { :user => user.attributes }
 503     post user_save_path, :params => { :read_ct => 1, :read_tou => 1 }
 504     confirm_string = User.find_by(:email => user.email).tokens.create.token
 505
 506     post logout_path
 507
 508     post user_confirm_path, :params => { :display_name => user.display_name, :confirm_string => confirm_string }
 509     assert_redirected_to login_path
 510     assert_match(/Confirmed your account/, flash[:notice])
 511   end
 512
 513   def test_confirm_success_good_token_no_referer
 514     user = build(:user, :pending)
 515     stub_gravatar_request(user.email)
 516     post user_new_path, :params => { :user => user.attributes }
 517     post user_save_path, :params => { :read_ct => 1, :read_tou => 1 }
 518     confirm_string = User.find_by(:email => user.email).tokens.create.token
 519
 520     post user_confirm_path, :params => { :display_name => user.display_name, :confirm_string => confirm_string }
 521     assert_redirected_to welcome_path
 522   end
 523
 524   def test_confirm_success_bad_token_no_referer
 525     user = build(:user, :pending)
 526     stub_gravatar_request(user.email)
 527     post user_new_path, :params => { :user => user.attributes }
 528     post user_save_path, :params => { :read_ct => 1, :read_tou => 1 }
 529     confirm_string = User.find_by(:email => user.email).tokens.create.token
 530
 531     post logout_path
 532     session_for(create(:user))
 533
 534     post user_confirm_path, :params => { :display_name => user.display_name, :confirm_string => confirm_string }
 535     assert_redirected_to login_path
 536     assert_match(/Confirmed your account/, flash[:notice])
 537   end
 538
 539   def test_confirm_success_no_token_with_referer
 540     user = build(:user, :pending)
 541     stub_gravatar_request(user.email)
 542     post user_new_path, :params => { :user => user.attributes }
 543     post user_save_path, :params => { :read_ct => 1, :read_tou => 1 }
 544     confirm_string = User.find_by(:email => user.email).tokens.create(:referer => new_diary_entry_path).token
 545
 546     post logout_path
 547
 548     post user_confirm_path, :params => { :display_name => user.display_name, :confirm_string => confirm_string }
 549     assert_redirected_to login_path(:referer => new_diary_entry_path)
 550     assert_match(/Confirmed your account/, flash[:notice])
 551   end
 552
 553   def test_confirm_success_good_token_with_referer
 554     user = build(:user, :pending)
 555     stub_gravatar_request(user.email)
 556     post user_new_path, :params => { :user => user.attributes }
 557     post user_save_path, :params => { :read_ct => 1, :read_tou => 1 }
 558     confirm_string = User.find_by(:email => user.email).tokens.create(:referer => new_diary_entry_path).token
 559
 560     post user_confirm_path, :params => { :display_name => user.display_name, :confirm_string => confirm_string }
 561     assert_redirected_to new_diary_entry_path
 562   end
 563
 564   def test_confirm_success_bad_token_with_referer
 565     user = build(:user, :pending)
 566     stub_gravatar_request(user.email)
 567     post user_new_path, :params => { :user => user.attributes }
 568     post user_save_path, :params => { :read_ct => 1, :read_tou => 1 }
 569     confirm_string = User.find_by(:email => user.email).tokens.create(:referer => new_diary_entry_path).token
 570
 571     post logout_path
 572     session_for(create(:user))
 573
 574     post user_confirm_path, :params => { :display_name => user.display_name, :confirm_string => confirm_string }
 575     assert_redirected_to login_path(:referer => new_diary_entry_path)
 576     assert_match(/Confirmed your account/, flash[:notice])
 577   end
 578
 579   def test_confirm_expired_token
 580     user = build(:user, :pending)
 581     stub_gravatar_request(user.email)
 582     post user_new_path, :params => { :user => user.attributes }
 583     post user_save_path, :params => { :read_ct => 1, :read_tou => 1 }
 584     confirm_string = User.find_by(:email => user.email).tokens.create(:expiry => 1.day.ago).token
 585
 586     post user_confirm_path, :params => { :display_name => user.display_name, :confirm_string => confirm_string }
 587     assert_redirected_to :action => "confirm"
 588     assert_match(/confirmation code has expired/, flash[:error])
 589   end
 590
 591   def test_confirm_already_confirmed
 592     user = build(:user, :pending)
 593     stub_gravatar_request(user.email)
 594     post user_new_path, :params => { :user => user.attributes }
 595     post user_save_path, :params => { :read_ct => 1, :read_tou => 1 }
 596     confirm_string = User.find_by(:email => user.email).tokens.create(:referer => new_diary_entry_path).token
 597
 598     post user_confirm_path, :params => { :display_name => user.display_name, :confirm_string => confirm_string }
 599     assert_redirected_to new_diary_entry_path
 600
 601     post logout_path
 602
 603     confirm_string = User.find_by(:email => user.email).tokens.create(:referer => new_diary_entry_path).token
 604     post user_confirm_path, :params => { :display_name => user.display_name, :confirm_string => confirm_string }
 605     assert_redirected_to :action => "login"
 606     assert_match(/already been confirmed/, flash[:error])
 607   end
 608
 609   def test_confirm_resend_success
 610     user = build(:user, :pending)
 611     post user_new_path, :params => { :user => user.attributes }
 612     post user_save_path, :params => { :read_ct => 1, :read_tou => 1 }
 613
 614     assert_difference "ActionMailer::Base.deliveries.size", 1 do
 615       perform_enqueued_jobs do
 616         get user_confirm_resend_path(user)
 617       end
 618     end
 619
 620     assert_response :redirect
 621     assert_redirected_to login_path
 622     assert_match(/sent a new confirmation/, flash[:notice])
 623
 624     email = ActionMailer::Base.deliveries.last
 625
 626     assert_equal user.email, email.to.first
 627
 628     ActionMailer::Base.deliveries.clear
 629   end
 630
 631   def test_confirm_resend_no_token
 632     user = build(:user, :pending)
 633     # only complete first half of registration
 634     post user_new_path, :params => { :user => user.attributes }
 635
 636     assert_no_difference "ActionMailer::Base.deliveries.size" do
 637       perform_enqueued_jobs do
 638         get user_confirm_resend_path(user)
 639       end
 640     end
 641
 642     assert_response :redirect
 643     assert_redirected_to login_path
 644     assert_match "User #{user.display_name} not found.", flash[:error]
 645   end
 646
 647   def test_confirm_resend_unknown_user
 648     assert_no_difference "ActionMailer::Base.deliveries.size" do
 649       perform_enqueued_jobs do
 650         get user_confirm_resend_path(:display_name => "No Such User")
 651       end
 652     end
 653
 654     assert_response :redirect
 655     assert_redirected_to login_path
 656     assert_match "User No Such User not found.", flash[:error]
 657   end
 658
 659   def test_confirm_email_get
 660     user = create(:user)
 661     confirm_string = user.tokens.create.token
 662
 663     get user_confirm_email_path, :params => { :confirm_string => confirm_string }
 664     assert_response :success
 665     assert_template :confirm_email
 666   end
 667
 668   def test_confirm_email_success
 669     user = create(:user, :new_email => "test-new@example.com")
 670     stub_gravatar_request(user.new_email)
 671     confirm_string = user.tokens.create.token
 672
 673     post user_confirm_email_path, :params => { :confirm_string => confirm_string }
 674     assert_response :redirect
 675     assert_redirected_to :action => :account, :display_name => user.display_name
 676     assert_match(/Confirmed your change of email address/, flash[:notice])
 677   end
 678
 679   def test_confirm_email_already_confirmed
 680     user = create(:user)
 681     confirm_string = user.tokens.create.token
 682
 683     post user_confirm_email_path, :params => { :confirm_string => confirm_string }
 684     assert_response :redirect
 685     assert_redirected_to :action => :account, :display_name => user.display_name
 686     assert_match(/already been confirmed/, flash[:error])
 687   end
 688
 689   def test_confirm_email_bad_token
 690     post user_confirm_email_path, :params => { :confirm_string => "XXXXX" }
 691     assert_response :success
 692     assert_template :confirm_email
 693     assert_match(/confirmation code has expired or does not exist/, flash[:error])
 694   end
 695
 696   ##
 697   # test if testing for a gravatar works
 698   # this happens when the email is actually changed
 699   # which is triggered by the confirmation mail
 700   def test_gravatar_auto_enable
 701     # switch to email that has a gravatar
 702     user = create(:user, :new_email => "test-new@example.com")
 703     stub_gravatar_request(user.new_email, 200)
 704     confirm_string = user.tokens.create.token
 705     # precondition gravatar should be turned off
 706     assert_not user.image_use_gravatar
 707     post user_confirm_email_path, :params => { :confirm_string => confirm_string }
 708     assert_response :redirect
 709     assert_redirected_to :action => :account, :display_name => user.display_name
 710     assert_match(/Confirmed your change of email address/, flash[:notice])
 711     # gravatar use should now be enabled
 712     assert User.find(user.id).image_use_gravatar
 713   end
 714
 715   def test_gravatar_auto_disable
 716     # switch to email without a gravatar
 717     user = create(:user, :new_email => "test-new@example.com", :image_use_gravatar => true)
 718     stub_gravatar_request(user.new_email, 404)
 719     confirm_string = user.tokens.create.token
 720     # precondition gravatar should be turned on
 721     assert user.image_use_gravatar
 722     post user_confirm_email_path, :params => { :confirm_string => confirm_string }
 723     assert_response :redirect
 724     assert_redirected_to :action => :account, :display_name => user.display_name
 725     assert_match(/Confirmed your change of email address/, flash[:notice])
 726     # gravatar use should now be disabled
 727     assert_not User.find(user.id).image_use_gravatar
 728   end
 729
 730   def test_terms_new_user
 731     user = build(:user, :pending)
 732
 733     # Set up our user as being half-way through registration
 734     assert_no_difference "User.count" do
 735       assert_no_difference "ActionMailer::Base.deliveries.size" do
 736         perform_enqueued_jobs do
 737           post user_new_path, :params => { :user => user.attributes }
 738         end
 739       end
 740     end
 741
 742     get user_terms_path
 743
 744     assert_response :success
 745     assert_template :terms
 746   end
 747
 748   def test_terms_agreed
 749     user = create(:user, :terms_seen => true, :terms_agreed => Date.yesterday)
 750
 751     session_for(user)
 752
 753     get user_terms_path
 754     assert_response :redirect
 755     assert_redirected_to :action => :account, :display_name => user.display_name
 756   end
 757
 758   def test_terms_not_seen_without_referer
 759     user = create(:user, :terms_seen => false, :terms_agreed => nil)
 760
 761     session_for(user)
 762
 763     get user_terms_path
 764     assert_response :success
 765     assert_template :terms
 766
 767     post user_save_path, :params => { :user => { :consider_pd => true }, :read_ct => 1, :read_tou => 1 }
 768     assert_response :redirect
 769     assert_redirected_to :action => :account, :display_name => user.display_name
 770     assert_equal "Thanks for accepting the new contributor terms!", flash[:notice]
 771
 772     user.reload
 773
 774     assert user.consider_pd
 775     assert_not_nil user.terms_agreed
 776     assert user.terms_seen
 777   end
 778
 779   def test_terms_not_seen_with_referer
 780     user = create(:user, :terms_seen => false, :terms_agreed => nil)
 781
 782     session_for(user)
 783
 784     get user_terms_path, :params => { :referer => "/test" }
 785     assert_response :success
 786     assert_template :terms
 787
 788     post user_save_path, :params => { :user => { :consider_pd => true }, :referer => "/test", :read_ct => 1, :read_tou => 1 }
 789     assert_response :redirect
 790     assert_redirected_to "/test"
 791     assert_equal "Thanks for accepting the new contributor terms!", flash[:notice]
 792
 793     user.reload
 794
 795     assert user.consider_pd
 796     assert_not_nil user.terms_agreed
 797     assert user.terms_seen
 798   end
 799
 800   # Check that if you haven't seen the terms, and make a request that requires authentication,
 801   # that your request is redirected to view the terms
 802   def test_terms_not_seen_redirection
 803     user = create(:user, :terms_seen => false, :terms_agreed => nil)
 804     session_for(user)
 805
 806     get user_account_path(user)
 807     assert_response :redirect
 808     assert_redirected_to :action => :terms, :referer => "/user/#{ERB::Util.u(user.display_name)}/account"
 809   end
 810
 811   def test_go_public
 812     user = create(:user, :data_public => false)
 813     session_for(user)
 814
 815     post user_go_public_path
 816
 817     assert_response :redirect
 818     assert_redirected_to :action => :account, :display_name => user.display_name
 819     assert User.find(user.id).data_public
 820   end
 821
 822   def test_lost_password
 823     # Test fetching the lost password page
 824     get user_forgot_password_path
 825     assert_response :success
 826     assert_template :lost_password
 827     assert_select "div#notice", false
 828
 829     # Test resetting using the address as recorded for a user that has an
 830     # address which is duplicated in a different case by another user
 831     user = create(:user)
 832     uppercase_user = build(:user, :email => user.email.upcase).tap { |u| u.save(:validate => false) }
 833
 834     # Resetting with GET should fail
 835     assert_no_difference "ActionMailer::Base.deliveries.size" do
 836       perform_enqueued_jobs do
 837         get user_forgot_password_path, :params => { :email => user.email }
 838       end
 839     end
 840     assert_response :success
 841     assert_template :lost_password
 842
 843     # Resetting with POST should work
 844     assert_difference "ActionMailer::Base.deliveries.size", 1 do
 845       perform_enqueued_jobs do
 846         post user_forgot_password_path, :params => { :email => user.email }
 847       end
 848     end
 849     assert_response :redirect
 850     assert_redirected_to :action => :login
 851     assert_match(/^Sorry you lost it/, flash[:notice])
 852     email = ActionMailer::Base.deliveries.first
 853     assert_equal 1, email.to.count
 854     assert_equal user.email, email.to.first
 855     ActionMailer::Base.deliveries.clear
 856
 857     # Test resetting using an address that matches a different user
 858     # that has the same address in a different case
 859     assert_difference "ActionMailer::Base.deliveries.size", 1 do
 860       perform_enqueued_jobs do
 861         post user_forgot_password_path, :params => { :email => user.email.upcase }
 862       end
 863     end
 864     assert_response :redirect
 865     assert_redirected_to :action => :login
 866     assert_match(/^Sorry you lost it/, flash[:notice])
 867     email = ActionMailer::Base.deliveries.first
 868     assert_equal 1, email.to.count
 869     assert_equal uppercase_user.email, email.to.first
 870     ActionMailer::Base.deliveries.clear
 871
 872     # Test resetting using an address that is a case insensitive match
 873     # for more than one user but not an exact match for either
 874     assert_no_difference "ActionMailer::Base.deliveries.size" do
 875       perform_enqueued_jobs do
 876         post user_forgot_password_path, :params => { :email => user.email.titlecase }
 877       end
 878     end
 879     assert_response :success
 880     assert_template :lost_password
 881     assert_select ".error", /^Could not find that email address/
 882
 883     # Test resetting using the address as recorded for a user that has an
 884     # address which is case insensitively unique
 885     third_user = create(:user)
 886     assert_difference "ActionMailer::Base.deliveries.size", 1 do
 887       perform_enqueued_jobs do
 888         post user_forgot_password_path, :params => { :email => third_user.email }
 889       end
 890     end
 891     assert_response :redirect
 892     assert_redirected_to :action => :login
 893     assert_match(/^Sorry you lost it/, flash[:notice])
 894     email = ActionMailer::Base.deliveries.first
 895     assert_equal 1, email.to.count
 896     assert_equal third_user.email, email.to.first
 897     ActionMailer::Base.deliveries.clear
 898
 899     # Test resetting using an address that matches a user that has the
 900     # same (case insensitively unique) address in a different case
 901     assert_difference "ActionMailer::Base.deliveries.size", 1 do
 902       perform_enqueued_jobs do
 903         post user_forgot_password_path, :params => { :email => third_user.email.upcase }
 904       end
 905     end
 906     assert_response :redirect
 907     assert_redirected_to :action => :login
 908     assert_match(/^Sorry you lost it/, flash[:notice])
 909     email = ActionMailer::Base.deliveries.first
 910     assert_equal 1, email.to.count
 911     assert_equal third_user.email, email.to.first
 912     ActionMailer::Base.deliveries.clear
 913   end
 914
 915   def test_reset_password
 916     user = create(:user, :pending)
 917     # Test a request with no token
 918     get user_reset_password_path
 919     assert_response :bad_request
 920
 921     # Test a request with a bogus token
 922     get user_reset_password_path, :params => { :token => "made_up_token" }
 923     assert_response :redirect
 924     assert_redirected_to :action => :lost_password
 925
 926     # Create a valid token for a user
 927     token = user.tokens.create
 928
 929     # Test a request with a valid token
 930     get user_reset_password_path, :params => { :token => token.token }
 931     assert_response :success
 932     assert_template :reset_password
 933
 934     # Test that errors are reported for erroneous submissions
 935     post user_reset_password_path, :params => { :token => token.token, :user => { :pass_crypt => "new_password", :pass_crypt_confirmation => "different_password" } }
 936     assert_response :success
 937     assert_template :reset_password
 938     assert_select "div.invalid-feedback"
 939
 940     # Test setting a new password
 941     post user_reset_password_path, :params => { :token => token.token, :user => { :pass_crypt => "new_password", :pass_crypt_confirmation => "new_password" } }
 942     assert_response :redirect
 943     assert_redirected_to root_path
 944     assert_equal user.id, session[:user]
 945     user.reload
 946     assert_equal "active", user.status
 947     assert user.email_valid
 948     assert_equal user, User.authenticate(:username => user.email, :password => "new_password")
 949   end
 950
 951   def test_account
 952     # Get a user to work with - note that this user deliberately
 953     # conflicts with uppercase_user in the email and display name
 954     # fields to test that we can change other fields without any
 955     # validation errors being reported
 956     user = create(:user, :languages => [])
 957     _uppercase_user = build(:user, :email => user.email.upcase, :display_name => user.display_name.upcase).tap { |u| u.save(:validate => false) }
 958
 959     # Make sure that you are redirected to the login page when
 960     # you are not logged in
 961     get user_account_path(user)
 962     assert_response :redirect
 963     assert_redirected_to :action => "login", :referer => "/user/#{ERB::Util.u(user.display_name)}/account"
 964
 965     # Make sure that you are blocked when not logged in as the right user
 966     session_for(create(:user))
 967     get user_account_path(user)
 968     assert_response :forbidden
 969
 970     # Make sure we get the page when we are logged in as the right user
 971     session_for(user)
 972     get user_account_path(user)
 973     assert_response :success
 974     assert_template :account
 975     assert_select "form#accountForm" do |form|
 976       assert_equal "post", form.attr("method").to_s
 977       assert_select "input[name='_method']", false
 978       assert_equal "/user/#{ERB::Util.u(user.display_name)}/account", form.attr("action").to_s
 979     end
 980
 981     # Updating the description using GET should fail
 982     user.description = "new description"
 983     user.preferred_editor = "default"
 984     get user_account_path(user), :params => { :user => user.attributes }
 985     assert_response :success
 986     assert_template :account
 987     assert_not_equal user.description, User.find(user.id).description
 988
 989     # Updating the description should work
 990     user.description = "new description"
 991     user.preferred_editor = "default"
 992     post user_account_path(user), :params => { :user => user.attributes }
 993     assert_response :redirect
 994     assert_redirected_to user_account_url(user)
 995     get user_account_path(user)
 996     assert_response :success
 997     assert_template :account
 998     assert_select ".notice", /^User information updated successfully/
 999     assert_select "form#accountForm > div.form-group > div#user_description_container > div#user_description_content > textarea#user_description", user.description
1000
1001     # Changing to a invalid editor should fail
1002     user.preferred_editor = "unknown"
1003     post user_account_path(user), :params => { :user => user.attributes }
1004     assert_response :success
1005     assert_template :account
1006     assert_select ".notice", false
1007     assert_select "form#accountForm > div.form-group > select#user_preferred_editor > option[selected]", false
1008
1009     # Changing to a valid editor should work
1010     user.preferred_editor = "id"
1011     post user_account_path(user), :params => { :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 ".notice", /^User information updated successfully/
1018     assert_select "form#accountForm > div.form-group > select#user_preferred_editor > option[selected][value=?]", "id"
1019
1020     # Changing to the default editor should work
1021     user.preferred_editor = "default"
1022     post user_account_path(user), :params => { :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 ".notice", /^User information updated successfully/
1029     assert_select "form#accountForm > div.form-group > select#user_preferred_editor > option[selected]", false
1030
1031     # Changing to an uploaded image should work
1032     image = Rack::Test::UploadedFile.new("test/gpx/fixtures/a.gif", "image/gif")
1033     post user_account_path(user), :params => { :avatar_action => "new", :user => user.attributes.merge(:avatar => image) }
1034     assert_response :redirect
1035     assert_redirected_to user_account_url(user)
1036     get user_account_path(user)
1037     assert_response :success
1038     assert_template :account
1039     assert_select ".notice", /^User information updated successfully/
1040     assert_select "form#accountForm > fieldset.form-group > div.form-row > div.col-sm-10 > div.form-check > input[name=avatar_action][checked][value=?]", "keep"
1041
1042     # Changing to a gravatar image should work
1043     post user_account_path(user), :params => { :avatar_action => "gravatar", :user => user.attributes }
1044     assert_response :redirect
1045     assert_redirected_to user_account_url(user)
1046     get user_account_path(user)
1047     assert_response :success
1048     assert_template :account
1049     assert_select ".notice", /^User information updated successfully/
1050     assert_select "form#accountForm > fieldset.form-group > div.form-row > div.col-sm-10 > div.form-group > div.form-check > input[name=avatar_action][checked][value=?]", "gravatar"
1051
1052     # Removing the image should work
1053     post user_account_path(user), :params => { :avatar_action => "delete", :user => user.attributes }
1054     assert_response :redirect
1055     assert_redirected_to user_account_url(user)
1056     get user_account_path(user)
1057     assert_response :success
1058     assert_template :account
1059     assert_select ".notice", /^User information updated successfully/
1060     assert_select "form#accountForm > fieldset.form-group > div.form-row > div.col-sm-10 > div.form-check > input[name=avatar_action][checked]", false
1061     assert_select "form#accountForm > fieldset.form-group > div.form-row > div.col-sm-10 > div.form-group > div.form-check > input[name=avatar_action][checked]", false
1062
1063     # Adding external authentication should redirect to the auth provider
1064     post user_account_path(user), :params => { :user => user.attributes.merge(:auth_provider => "openid", :auth_uid => "gmail.com") }
1065     assert_response :redirect
1066     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")
1067
1068     # Changing name to one that exists should fail
1069     new_attributes = user.attributes.dup.merge(:display_name => create(:user).display_name)
1070     post user_account_path(user), :params => { :user => new_attributes }
1071     assert_response :success
1072     assert_template :account
1073     assert_select ".notice", false
1074     assert_select "form#accountForm > div.form-group > input.is-invalid#user_display_name"
1075
1076     # Changing name to one that exists should fail, regardless of case
1077     new_attributes = user.attributes.dup.merge(:display_name => create(:user).display_name.upcase)
1078     post user_account_path(user), :params => { :user => new_attributes }
1079     assert_response :success
1080     assert_template :account
1081     assert_select ".notice", false
1082     assert_select "form#accountForm > div.form-group > input.is-invalid#user_display_name"
1083
1084     # Changing name to one that doesn't exist should work
1085     new_attributes = user.attributes.dup.merge(:display_name => "new tester")
1086     post user_account_path(user), :params => { :user => new_attributes }
1087     assert_response :redirect
1088     assert_redirected_to user_account_url(:display_name => "new tester")
1089     get user_account_path(:display_name => "new tester")
1090     assert_response :success
1091     assert_template :account
1092     assert_select ".notice", /^User information updated successfully/
1093     assert_select "form#accountForm > div.form-group > input#user_display_name[value=?]", "new tester"
1094
1095     # Record the change of name
1096     user.display_name = "new tester"
1097
1098     # Changing email to one that exists should fail
1099     user.new_email = create(:user).email
1100     assert_no_difference "ActionMailer::Base.deliveries.size" do
1101       perform_enqueued_jobs do
1102         post user_account_path(user), :params => { :user => user.attributes }
1103       end
1104     end
1105     assert_response :success
1106     assert_template :account
1107     assert_select ".notice", false
1108     assert_select "form#accountForm > div.form-group > input.is-invalid#user_new_email"
1109
1110     # Changing email to one that exists should fail, regardless of case
1111     user.new_email = create(:user).email.upcase
1112     assert_no_difference "ActionMailer::Base.deliveries.size" do
1113       perform_enqueued_jobs do
1114         post user_account_path(user), :params => { :user => user.attributes }
1115       end
1116     end
1117     assert_response :success
1118     assert_template :account
1119     assert_select ".notice", false
1120     assert_select "form#accountForm > div.form-group > input.is-invalid#user_new_email"
1121
1122     # Changing email to one that doesn't exist should work
1123     user.new_email = "new_tester@example.com"
1124     assert_difference "ActionMailer::Base.deliveries.size", 1 do
1125       perform_enqueued_jobs do
1126         post user_account_path(user), :params => { :user => user.attributes }
1127       end
1128     end
1129     assert_response :redirect
1130     assert_redirected_to user_account_url(user)
1131     get user_account_path(user)
1132     assert_response :success
1133     assert_template :account
1134     assert_select ".notice", /^User information updated successfully/
1135     assert_select "form#accountForm > div.form-group > input#user_new_email[value=?]", user.new_email
1136     email = ActionMailer::Base.deliveries.first
1137     assert_equal 1, email.to.count
1138     assert_equal user.new_email, email.to.first
1139     ActionMailer::Base.deliveries.clear
1140   end
1141
1142   # Check that the user account page will display and contains some relevant
1143   # information for the user
1144   def test_show
1145     # Test a non-existent user
1146     get user_path(:display_name => "unknown")
1147     assert_response :not_found
1148
1149     # Test a normal user
1150     user = create(:user, :home_lon => 1.1, :home_lat => 1.1)
1151     friend_user = create(:user, :home_lon => 1.2, :home_lat => 1.2)
1152     create(:friendship, :befriender => user, :befriendee => friend_user)
1153     create(:changeset, :user => friend_user)
1154
1155     get user_path(user)
1156     assert_response :success
1157     assert_select "div#userinformation" do
1158       assert_select "a[href^='/user/#{ERB::Util.u(user.display_name)}/history']", 1
1159       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/traces']", 1
1160       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/diary']", 1
1161       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/diary/comments']", 1
1162       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/account']", 0
1163       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/blocks']", 0
1164       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/blocks_by']", 0
1165       assert_select "a[href='/blocks/new/#{ERB::Util.u(user.display_name)}']", 0
1166     end
1167
1168     # Friends shouldn't be visible as we're not logged in
1169     assert_select "div#friends-container", :count => 0
1170
1171     # Test a user who has been blocked
1172     blocked_user = create(:user)
1173     create(:user_block, :user => blocked_user)
1174     get user_path(blocked_user)
1175     assert_response :success
1176     assert_select "div#userinformation" do
1177       assert_select "a[href^='/user/#{ERB::Util.u(blocked_user.display_name)}/history']", 1
1178       assert_select "a[href='/user/#{ERB::Util.u(blocked_user.display_name)}/traces']", 1
1179       assert_select "a[href='/user/#{ERB::Util.u(blocked_user.display_name)}/diary']", 1
1180       assert_select "a[href='/user/#{ERB::Util.u(blocked_user.display_name)}/diary/comments']", 1
1181       assert_select "a[href='/user/#{ERB::Util.u(blocked_user.display_name)}/account']", 0
1182       assert_select "a[href='/user/#{ERB::Util.u(blocked_user.display_name)}/blocks']", 1
1183       assert_select "a[href='/user/#{ERB::Util.u(blocked_user.display_name)}/blocks_by']", 0
1184       assert_select "a[href='/blocks/new/#{ERB::Util.u(blocked_user.display_name)}']", 0
1185     end
1186
1187     # Test a moderator who has applied blocks
1188     moderator_user = create(:moderator_user)
1189     create(:user_block, :creator => moderator_user)
1190     get user_path(moderator_user)
1191     assert_response :success
1192     assert_select "div#userinformation" do
1193       assert_select "a[href^='/user/#{ERB::Util.u(moderator_user.display_name)}/history']", 1
1194       assert_select "a[href='/user/#{ERB::Util.u(moderator_user.display_name)}/traces']", 1
1195       assert_select "a[href='/user/#{ERB::Util.u(moderator_user.display_name)}/diary']", 1
1196       assert_select "a[href='/user/#{ERB::Util.u(moderator_user.display_name)}/diary/comments']", 1
1197       assert_select "a[href='/user/#{ERB::Util.u(moderator_user.display_name)}/account']", 0
1198       assert_select "a[href='/user/#{ERB::Util.u(moderator_user.display_name)}/blocks']", 0
1199       assert_select "a[href='/user/#{ERB::Util.u(moderator_user.display_name)}/blocks_by']", 1
1200       assert_select "a[href='/blocks/new/#{ERB::Util.u(moderator_user.display_name)}']", 0
1201     end
1202
1203     # Login as a normal user
1204     session_for(user)
1205
1206     # Test the normal user
1207     get user_path(user)
1208     assert_response :success
1209     assert_select "div#userinformation" do
1210       assert_select "a[href^='/user/#{ERB::Util.u(user.display_name)}/history']", 1
1211       assert_select "a[href='/traces/mine']", 1
1212       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/diary']", 1
1213       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/diary/comments']", 1
1214       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/account']", 1
1215       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/blocks']", 0
1216       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/blocks_by']", 0
1217       assert_select "a[href='/blocks/new/#{ERB::Util.u(user.display_name)}']", 0
1218     end
1219
1220     # Friends should be visible as we're now logged in
1221     assert_select "div#friends-container" do
1222       assert_select "div.contact-activity", :count => 1
1223     end
1224
1225     # Login as a moderator
1226     session_for(create(:moderator_user))
1227
1228     # Test the normal user
1229     get user_path(user)
1230     assert_response :success
1231     assert_select "div#userinformation" do
1232       assert_select "a[href^='/user/#{ERB::Util.u(user.display_name)}/history']", 1
1233       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/traces']", 1
1234       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/diary']", 1
1235       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/diary/comments']", 1
1236       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/account']", 0
1237       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/blocks']", 0
1238       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/blocks_by']", 0
1239       assert_select "a[href='/blocks/new/#{ERB::Util.u(user.display_name)}']", 1
1240     end
1241   end
1242
1243   # Test whether information about contributor terms is shown for users who haven't agreed
1244   def test_terms_not_agreed
1245     agreed_user = create(:user, :terms_agreed => 3.days.ago)
1246     seen_user = create(:user, :terms_seen => true, :terms_agreed => nil)
1247     not_seen_user = create(:user, :terms_seen => false, :terms_agreed => nil)
1248
1249     get user_path(agreed_user)
1250     assert_response :success
1251     assert_select "div#userinformation" do
1252       assert_select "p", :count => 0, :text => /Contributor terms/
1253     end
1254
1255     get user_path(seen_user)
1256     assert_response :success
1257     # put @response.body
1258     assert_select "div#userinformation" do
1259       assert_select "p", :count => 1, :text => /Contributor terms/
1260       assert_select "p", /Declined/
1261     end
1262
1263     get user_path(not_seen_user)
1264     assert_response :success
1265     assert_select "div#userinformation" do
1266       assert_select "p", :count => 1, :text => /Contributor terms/
1267       assert_select "p", /Undecided/
1268     end
1269   end
1270
1271   def test_set_status
1272     user = create(:user)
1273
1274     # Try without logging in
1275     post set_status_user_path(user), :params => { :status => "suspended" }
1276     assert_response :forbidden
1277
1278     # Now try as a normal user
1279     session_for(user)
1280     post set_status_user_path(user), :params => { :status => "suspended" }
1281     assert_response :redirect
1282     assert_redirected_to :controller => :errors, :action => :forbidden
1283
1284     # Finally try as an administrator
1285     session_for(create(:administrator_user))
1286     post set_status_user_path(user), :params => { :status => "suspended" }
1287     assert_response :redirect
1288     assert_redirected_to :action => :show, :display_name => user.display_name
1289     assert_equal "suspended", User.find(user.id).status
1290   end
1291
1292   def test_destroy
1293     user = create(:user, :home_lat => 12.1, :home_lon => 12.1, :description => "test")
1294
1295     # Try without logging in
1296     delete user_path(user), :params => { :status => "suspended" }
1297     assert_response :forbidden
1298
1299     # Now try as a normal user
1300     session_for(user)
1301     delete user_path(user), :params => { :status => "suspended" }
1302     assert_response :redirect
1303     assert_redirected_to :controller => :errors, :action => :forbidden
1304
1305     # Finally try as an administrator
1306     session_for(create(:administrator_user))
1307     delete user_path(user), :params => { :status => "suspended" }
1308     assert_response :redirect
1309     assert_redirected_to :action => :show, :display_name => user.display_name
1310
1311     # Check that the user was deleted properly
1312     user.reload
1313     assert_equal "user_#{user.id}", user.display_name
1314     assert_equal "", user.description
1315     assert_nil user.home_lat
1316     assert_nil user.home_lon
1317     assert_not user.avatar.attached?
1318     assert_not user.email_valid
1319     assert_nil user.new_email
1320     assert_nil user.auth_provider
1321     assert_nil user.auth_uid
1322     assert_equal "deleted", user.status
1323   end
1324
1325   def test_index_get
1326     user = create(:user)
1327     moderator_user = create(:moderator_user)
1328     administrator_user = create(:administrator_user)
1329     _suspended_user = create(:user, :suspended)
1330     _ip_user = create(:user, :creation_ip => "1.2.3.4")
1331
1332     # There are now 7 users - the five above, plus two extra "granters" for the
1333     # moderator_user and administrator_user
1334     assert_equal 7, User.count
1335
1336     # Shouldn't work when not logged in
1337     get users_path
1338     assert_response :redirect
1339     assert_redirected_to :action => :login, :referer => users_path
1340
1341     session_for(user)
1342
1343     # Shouldn't work when logged in as a normal user
1344     get users_path
1345     assert_response :redirect
1346     assert_redirected_to :controller => :errors, :action => :forbidden
1347
1348     session_for(moderator_user)
1349
1350     # Shouldn't work when logged in as a moderator
1351     get users_path
1352     assert_response :redirect
1353     assert_redirected_to :controller => :errors, :action => :forbidden
1354
1355     session_for(administrator_user)
1356
1357     # Note there is a header row, so all row counts are users + 1
1358     # Should work when logged in as an administrator
1359     get users_path
1360     assert_response :success
1361     assert_template :index
1362     assert_select "table#user_list tr", :count => 7 + 1
1363
1364     # Should be able to limit by status
1365     get users_path, :params => { :status => "suspended" }
1366     assert_response :success
1367     assert_template :index
1368     assert_select "table#user_list tr", :count => 1 + 1
1369
1370     # Should be able to limit by IP address
1371     get users_path, :params => { :ip => "1.2.3.4" }
1372     assert_response :success
1373     assert_template :index
1374     assert_select "table#user_list tr", :count => 1 + 1
1375   end
1376
1377   def test_index_get_paginated
1378     1.upto(100).each do |n|
1379       User.create(:display_name => "extra_#{n}",
1380                   :email => "extra#{n}@example.com",
1381                   :pass_crypt => "extraextra")
1382     end
1383
1384     session_for(create(:administrator_user))
1385
1386     # 100 examples, an administrator, and a granter for the admin.
1387     assert_equal 102, User.count
1388
1389     get users_path
1390     assert_response :success
1391     assert_template :index
1392     assert_select "table#user_list tr", :count => 51
1393
1394     get users_path, :params => { :page => 2 }
1395     assert_response :success
1396     assert_template :index
1397     assert_select "table#user_list tr", :count => 51
1398
1399     get users_path, :params => { :page => 3 }
1400     assert_response :success
1401     assert_template :index
1402     assert_select "table#user_list tr", :count => 3
1403   end
1404
1405   def test_index_post_confirm
1406     inactive_user = create(:user, :pending)
1407     suspended_user = create(:user, :suspended)
1408
1409     # Shouldn't work when not logged in
1410     assert_no_difference "User.active.count" do
1411       post users_path, :params => { :confirm => 1, :user => { inactive_user.id => 1, suspended_user.id => 1 } }
1412     end
1413     assert_response :forbidden
1414
1415     assert_equal "pending", inactive_user.reload.status
1416     assert_equal "suspended", suspended_user.reload.status
1417
1418     session_for(create(:user))
1419
1420     # Shouldn't work when logged in as a normal user
1421     assert_no_difference "User.active.count" do
1422       post users_path, :params => { :confirm => 1, :user => { inactive_user.id => 1, suspended_user.id => 1 } }
1423     end
1424     assert_response :redirect
1425     assert_redirected_to :controller => :errors, :action => :forbidden
1426     assert_equal "pending", inactive_user.reload.status
1427     assert_equal "suspended", suspended_user.reload.status
1428
1429     session_for(create(:moderator_user))
1430
1431     # Shouldn't work when logged in as a moderator
1432     assert_no_difference "User.active.count" do
1433       post users_path, :params => { :confirm => 1, :user => { inactive_user.id => 1, suspended_user.id => 1 } }
1434     end
1435     assert_response :redirect
1436     assert_redirected_to :controller => :errors, :action => :forbidden
1437     assert_equal "pending", inactive_user.reload.status
1438     assert_equal "suspended", suspended_user.reload.status
1439
1440     session_for(create(:administrator_user))
1441
1442     # Should work when logged in as an administrator
1443     assert_difference "User.active.count", 2 do
1444       post users_path, :params => { :confirm => 1, :user => { inactive_user.id => 1, suspended_user.id => 1 } }
1445     end
1446     assert_response :redirect
1447     assert_redirected_to :action => :index
1448     assert_equal "confirmed", inactive_user.reload.status
1449     assert_equal "confirmed", suspended_user.reload.status
1450   end
1451
1452   def test_index_post_hide
1453     normal_user = create(:user)
1454     confirmed_user = create(:user, :confirmed)
1455
1456     # Shouldn't work when not logged in
1457     assert_no_difference "User.active.count" do
1458       post users_path, :params => { :hide => 1, :user => { normal_user.id => 1, confirmed_user.id => 1 } }
1459     end
1460     assert_response :forbidden
1461
1462     assert_equal "active", normal_user.reload.status
1463     assert_equal "confirmed", confirmed_user.reload.status
1464
1465     session_for(create(:user))
1466
1467     # Shouldn't work when logged in as a normal user
1468     assert_no_difference "User.active.count" do
1469       post users_path, :params => { :hide => 1, :user => { normal_user.id => 1, confirmed_user.id => 1 } }
1470     end
1471     assert_response :redirect
1472     assert_redirected_to :controller => :errors, :action => :forbidden
1473     assert_equal "active", normal_user.reload.status
1474     assert_equal "confirmed", confirmed_user.reload.status
1475
1476     session_for(create(:moderator_user))
1477
1478     # Shouldn't work when logged in as a moderator
1479     assert_no_difference "User.active.count" do
1480       post users_path, :params => { :hide => 1, :user => { normal_user.id => 1, confirmed_user.id => 1 } }
1481     end
1482     assert_response :redirect
1483     assert_redirected_to :controller => :errors, :action => :forbidden
1484     assert_equal "active", normal_user.reload.status
1485     assert_equal "confirmed", confirmed_user.reload.status
1486
1487     session_for(create(:administrator_user))
1488
1489     # Should work when logged in as an administrator
1490     assert_difference "User.active.count", -2 do
1491       post users_path, :params => { :hide => 1, :user => { normal_user.id => 1, confirmed_user.id => 1 } }
1492     end
1493     assert_response :redirect
1494     assert_redirected_to :action => :index
1495     assert_equal "deleted", normal_user.reload.status
1496     assert_equal "deleted", confirmed_user.reload.status
1497   end
1498 end