test/controllers/users_controller_test.rb

   1 require "test_helper"
   2
   3 class UsersControllerTest < ActionDispatch::IntegrationTest
   4   ##
   5   # test all routes which lead to this controller
   6   def test_routes
   7     assert_routing(
   8       { :path => "/user/new", :method => :get },
   9       { :controller => "users", :action => "new" }
  10     )
  11
  12     assert_routing(
  13       { :path => "/user/new", :method => :post },
  14       { :controller => "users", :action => "create" }
  15     )
  16
  17     assert_routing(
  18       { :path => "/user/terms", :method => :get },
  19       { :controller => "users", :action => "terms" }
  20     )
  21
  22     assert_routing(
  23       { :path => "/user/save", :method => :post },
  24       { :controller => "users", :action => "save" }
  25     )
  26
  27     assert_routing(
  28       { :path => "/user/go_public", :method => :post },
  29       { :controller => "users", :action => "go_public" }
  30     )
  31
  32     assert_routing(
  33       { :path => "/user/suspended", :method => :get },
  34       { :controller => "users", :action => "suspended" }
  35     )
  36
  37     assert_routing(
  38       { :path => "/user/username", :method => :get },
  39       { :controller => "users", :action => "show", :display_name => "username" }
  40     )
  41
  42     assert_routing(
  43       { :path => "/user/username/account", :method => :get },
  44       { :controller => "users", :action => "account", :display_name => "username" }
  45     )
  46     assert_routing(
  47       { :path => "/user/username/account", :method => :post },
  48       { :controller => "users", :action => "account", :display_name => "username" }
  49     )
  50
  51     assert_routing(
  52       { :path => "/user/username/set_status", :method => :post },
  53       { :controller => "users", :action => "set_status", :display_name => "username" }
  54     )
  55     assert_routing(
  56       { :path => "/user/username", :method => :delete },
  57       { :controller => "users", :action => "destroy", :display_name => "username" }
  58     )
  59
  60     assert_routing(
  61       { :path => "/users", :method => :get },
  62       { :controller => "users", :action => "index" }
  63     )
  64     assert_routing(
  65       { :path => "/users", :method => :post },
  66       { :controller => "users", :action => "index" }
  67     )
  68     assert_routing(
  69       { :path => "/users/status", :method => :get },
  70       { :controller => "users", :action => "index", :status => "status" }
  71     )
  72     assert_routing(
  73       { :path => "/users/status", :method => :post },
  74       { :controller => "users", :action => "index", :status => "status" }
  75     )
  76   end
  77
  78   # The user creation page loads
  79   def test_new_view
  80     get user_new_path
  81     assert_response :redirect
  82     assert_redirected_to user_new_path(:cookie_test => "true")
  83
  84     get user_new_path, :params => { :cookie_test => "true" }
  85     assert_response :success
  86
  87     assert_select "html", :count => 1 do
  88       assert_select "head", :count => 1 do
  89         assert_select "title", :text => /Sign Up/, :count => 1
  90       end
  91       assert_select "body", :count => 1 do
  92         assert_select "div#content", :count => 1 do
  93           assert_select "form[action='/user/new'][method='post']", :count => 1 do
  94             assert_select "input[id='user_email']", :count => 1
  95             assert_select "input[id='user_email_confirmation']", :count => 1
  96             assert_select "input[id='user_display_name']", :count => 1
  97             assert_select "input[id='user_pass_crypt'][type='password']", :count => 1
  98             assert_select "input[id='user_pass_crypt_confirmation'][type='password']", :count => 1
  99             assert_select "input[type='submit'][value='Sign Up']", :count => 1
 100           end
 101         end
 102       end
 103     end
 104   end
 105
 106   def test_new_view_logged_in
 107     session_for(create(:user))
 108
 109     get user_new_path
 110     assert_response :redirect
 111     assert_redirected_to root_path
 112
 113     get user_new_path, :params => { :referer => "/test" }
 114     assert_response :redirect
 115     assert_redirected_to "/test"
 116   end
 117
 118   def test_new_success
 119     user = build(:user, :pending)
 120
 121     assert_no_difference "User.count" do
 122       assert_no_difference "ActionMailer::Base.deliveries.size" do
 123         perform_enqueued_jobs do
 124           post user_new_path, :params => { :user => user.attributes }
 125         end
 126       end
 127     end
 128
 129     assert_difference "User.count", 1 do
 130       assert_difference "ActionMailer::Base.deliveries.size", 1 do
 131         perform_enqueued_jobs do
 132           post user_save_path, :params => { :read_ct => 1, :read_tou => 1 }
 133         end
 134       end
 135     end
 136
 137     # Check the e-mail
 138     register_email = ActionMailer::Base.deliveries.first
 139
 140     assert_equal register_email.to[0], user.email
 141     assert_match(/#{@url}/, register_email.body.to_s)
 142
 143     # Check the page
 144     assert_redirected_to :controller => :confirmations, :action => :confirm, :display_name => user.display_name
 145
 146     ActionMailer::Base.deliveries.clear
 147   end
 148
 149   def test_new_duplicate_email
 150     user = build(:user, :pending)
 151     create(:user, :email => user.email)
 152
 153     assert_no_difference "User.count" do
 154       assert_no_difference "ActionMailer::Base.deliveries.size" do
 155         perform_enqueued_jobs do
 156           post user_new_path, :params => { :user => user.attributes }
 157         end
 158       end
 159     end
 160
 161     assert_response :success
 162     assert_template "new"
 163     assert_select "form > div.form-group > input.is-invalid#user_email"
 164   end
 165
 166   def test_save_duplicate_email
 167     user = build(:user, :pending)
 168
 169     # Set up our user as being half-way through registration
 170     assert_no_difference "User.count" do
 171       assert_no_difference "ActionMailer::Base.deliveries.size" do
 172         perform_enqueued_jobs do
 173           post user_new_path, :params => { :user => user.attributes }
 174         end
 175       end
 176     end
 177
 178     # Now create another user with that email
 179     create(:user, :email => user.email)
 180
 181     # Check that the second half of registration fails
 182     assert_no_difference "User.count" do
 183       assert_no_difference "ActionMailer::Base.deliveries.size" do
 184         perform_enqueued_jobs do
 185           post user_save_path, :params => { :read_ct => 1, :read_tou => 1 }
 186         end
 187       end
 188     end
 189
 190     assert_response :success
 191     assert_template "new"
 192     assert_select "form > div.form-group > input.is-invalid#user_email"
 193   end
 194
 195   def test_save_duplicate_email_uppercase
 196     user = build(:user, :pending)
 197
 198     # Set up our user as being half-way through registration
 199     assert_no_difference "User.count" do
 200       assert_no_difference "ActionMailer::Base.deliveries.size" do
 201         perform_enqueued_jobs do
 202           post user_new_path, :params => { :user => user.attributes }
 203         end
 204       end
 205     end
 206
 207     # Now create another user with that email, but uppercased
 208     create(:user, :email => user.email.upcase)
 209
 210     # Check that the second half of registration fails
 211     assert_no_difference "User.count" do
 212       assert_no_difference "ActionMailer::Base.deliveries.size" do
 213         perform_enqueued_jobs do
 214           post user_save_path, :params => { :read_ct => 1, :read_tou => 1 }
 215         end
 216       end
 217     end
 218
 219     assert_response :success
 220     assert_template "new"
 221     assert_select "form > div.form-group > input.is-invalid#user_email"
 222   end
 223
 224   def test_save_duplicate_name
 225     user = build(:user, :pending)
 226
 227     # Set up our user as being half-way through registration
 228     assert_no_difference "User.count" do
 229       assert_no_difference "ActionMailer::Base.deliveries.size" do
 230         perform_enqueued_jobs do
 231           post user_new_path, :params => { :user => user.attributes }
 232         end
 233       end
 234     end
 235
 236     # Now create another user with that display name
 237     create(:user, :display_name => user.display_name)
 238
 239     # Check that the second half of registration fails
 240     assert_no_difference "User.count" do
 241       assert_no_difference "ActionMailer::Base.deliveries.size" do
 242         perform_enqueued_jobs do
 243           post user_save_path, :params => { :read_ct => 1, :read_tou => 1 }
 244         end
 245       end
 246     end
 247
 248     assert_response :success
 249     assert_template "new"
 250     assert_select "form > div.form-group > input.is-invalid#user_display_name"
 251   end
 252
 253   def test_save_duplicate_name_uppercase
 254     user = build(:user, :pending)
 255
 256     # Set up our user as being half-way through registration
 257     assert_no_difference "User.count" do
 258       assert_no_difference "ActionMailer::Base.deliveries.size" do
 259         perform_enqueued_jobs do
 260           post user_new_path, :params => { :user => user.attributes }
 261         end
 262       end
 263     end
 264
 265     # Now create another user with that display_name, but uppercased
 266     create(:user, :display_name => user.display_name.upcase)
 267
 268     # Check that the second half of registration fails
 269     assert_no_difference "User.count" do
 270       assert_no_difference "ActionMailer::Base.deliveries.size" do
 271         perform_enqueued_jobs do
 272           post user_save_path, :params => { :read_ct => 1, :read_tou => 1 }
 273         end
 274       end
 275     end
 276
 277     assert_response :success
 278     assert_template "new"
 279     assert_select "form > div.form-group > input.is-invalid#user_display_name"
 280   end
 281
 282   def test_save_blocked_domain
 283     user = build(:user, :pending, :email => "user@example.net")
 284
 285     # Set up our user as being half-way through registration
 286     assert_no_difference "User.count" do
 287       assert_no_difference "ActionMailer::Base.deliveries.size" do
 288         perform_enqueued_jobs do
 289           post user_new_path, :params => { :user => user.attributes }
 290         end
 291       end
 292     end
 293
 294     # Now block that domain
 295     create(:acl, :domain => "example.net", :k => "no_account_creation")
 296
 297     # Check that the second half of registration fails
 298     assert_no_difference "User.count" do
 299       assert_no_difference "ActionMailer::Base.deliveries.size" do
 300         perform_enqueued_jobs do
 301           post user_save_path, :params => { :read_ct => 1, :read_tou => 1 }
 302         end
 303       end
 304     end
 305
 306     assert_response :success
 307     assert_template "blocked"
 308   end
 309
 310   def test_save_referer_params
 311     user = build(:user, :pending)
 312
 313     # Set up our user as being half-way through registration
 314     assert_no_difference "User.count" do
 315       assert_no_difference "ActionMailer::Base.deliveries.size" do
 316         perform_enqueued_jobs do
 317           post user_new_path, :params => { :user => user.attributes, :referer => "/edit?editor=id#map=1/2/3" }
 318         end
 319       end
 320     end
 321
 322     assert_difference "User.count", 1 do
 323       assert_difference "ActionMailer::Base.deliveries.size", 1 do
 324         perform_enqueued_jobs do
 325           post user_save_path, :params => { :read_ct => 1, :read_tou => 1 }
 326         end
 327       end
 328     end
 329
 330     assert_equal welcome_path(:editor => "id", :zoom => 1, :lat => 2, :lon => 3),
 331                  User.find_by(:email => user.email).tokens.order("id DESC").first.referer
 332
 333     ActionMailer::Base.deliveries.clear
 334   end
 335
 336   def test_terms_new_user
 337     user = build(:user, :pending)
 338
 339     # Set up our user as being half-way through registration
 340     assert_no_difference "User.count" do
 341       assert_no_difference "ActionMailer::Base.deliveries.size" do
 342         perform_enqueued_jobs do
 343           post user_new_path, :params => { :user => user.attributes }
 344         end
 345       end
 346     end
 347
 348     get user_terms_path
 349
 350     assert_response :success
 351     assert_template :terms
 352   end
 353
 354   def test_terms_agreed
 355     user = create(:user, :terms_seen => true, :terms_agreed => Date.yesterday)
 356
 357     session_for(user)
 358
 359     get user_terms_path
 360     assert_response :redirect
 361     assert_redirected_to :action => :account, :display_name => user.display_name
 362   end
 363
 364   def test_terms_not_seen_without_referer
 365     user = create(:user, :terms_seen => false, :terms_agreed => nil)
 366
 367     session_for(user)
 368
 369     get user_terms_path
 370     assert_response :success
 371     assert_template :terms
 372
 373     post user_save_path, :params => { :user => { :consider_pd => true }, :read_ct => 1, :read_tou => 1 }
 374     assert_response :redirect
 375     assert_redirected_to :action => :account, :display_name => user.display_name
 376     assert_equal "Thanks for accepting the new contributor terms!", flash[:notice]
 377
 378     user.reload
 379
 380     assert user.consider_pd
 381     assert_not_nil user.terms_agreed
 382     assert user.terms_seen
 383   end
 384
 385   def test_terms_not_seen_with_referer
 386     user = create(:user, :terms_seen => false, :terms_agreed => nil)
 387
 388     session_for(user)
 389
 390     get user_terms_path, :params => { :referer => "/test" }
 391     assert_response :success
 392     assert_template :terms
 393
 394     post user_save_path, :params => { :user => { :consider_pd => true }, :referer => "/test", :read_ct => 1, :read_tou => 1 }
 395     assert_response :redirect
 396     assert_redirected_to "/test"
 397     assert_equal "Thanks for accepting the new contributor terms!", flash[:notice]
 398
 399     user.reload
 400
 401     assert user.consider_pd
 402     assert_not_nil user.terms_agreed
 403     assert user.terms_seen
 404   end
 405
 406   # Check that if you haven't seen the terms, and make a request that requires authentication,
 407   # that your request is redirected to view the terms
 408   def test_terms_not_seen_redirection
 409     user = create(:user, :terms_seen => false, :terms_agreed => nil)
 410     session_for(user)
 411
 412     get user_account_path(user)
 413     assert_response :redirect
 414     assert_redirected_to :action => :terms, :referer => "/user/#{ERB::Util.u(user.display_name)}/account"
 415   end
 416
 417   def test_go_public
 418     user = create(:user, :data_public => false)
 419     session_for(user)
 420
 421     post user_go_public_path
 422
 423     assert_response :redirect
 424     assert_redirected_to :action => :account, :display_name => user.display_name
 425     assert User.find(user.id).data_public
 426   end
 427
 428   def test_account
 429     # Get a user to work with - note that this user deliberately
 430     # conflicts with uppercase_user in the email and display name
 431     # fields to test that we can change other fields without any
 432     # validation errors being reported
 433     user = create(:user, :languages => [])
 434     _uppercase_user = build(:user, :email => user.email.upcase, :display_name => user.display_name.upcase).tap { |u| u.save(:validate => false) }
 435
 436     # Make sure that you are redirected to the login page when
 437     # you are not logged in
 438     get user_account_path(user)
 439     assert_response :redirect
 440     assert_redirected_to login_path(:referer => "/user/#{ERB::Util.u(user.display_name)}/account")
 441
 442     # Make sure that you are blocked when not logged in as the right user
 443     session_for(create(:user))
 444     get user_account_path(user)
 445     assert_response :forbidden
 446
 447     # Make sure we get the page when we are logged in as the right user
 448     session_for(user)
 449     get user_account_path(user)
 450     assert_response :success
 451     assert_template :account
 452     assert_select "form#accountForm" do |form|
 453       assert_equal "post", form.attr("method").to_s
 454       assert_select "input[name='_method']", false
 455       assert_equal "/user/#{ERB::Util.u(user.display_name)}/account", form.attr("action").to_s
 456     end
 457
 458     # Updating the description using GET should fail
 459     user.description = "new description"
 460     user.preferred_editor = "default"
 461     get user_account_path(user), :params => { :user => user.attributes }
 462     assert_response :success
 463     assert_template :account
 464     assert_not_equal user.description, User.find(user.id).description
 465
 466     # Updating the description should work
 467     user.description = "new description"
 468     user.preferred_editor = "default"
 469     post user_account_path(user), :params => { :user => user.attributes }
 470     assert_response :redirect
 471     assert_redirected_to user_account_url(user)
 472     get user_account_path(user)
 473     assert_response :success
 474     assert_template :account
 475     assert_select ".notice", /^User information updated successfully/
 476     assert_select "form#accountForm > div.form-group > div#user_description_container > div#user_description_content > textarea#user_description", user.description
 477
 478     # Changing to a invalid editor should fail
 479     user.preferred_editor = "unknown"
 480     post user_account_path(user), :params => { :user => user.attributes }
 481     assert_response :success
 482     assert_template :account
 483     assert_select ".notice", false
 484     assert_select "form#accountForm > div.form-group > select#user_preferred_editor > option[selected]", false
 485
 486     # Changing to a valid editor should work
 487     user.preferred_editor = "id"
 488     post user_account_path(user), :params => { :user => user.attributes }
 489     assert_response :redirect
 490     assert_redirected_to user_account_url(user)
 491     get user_account_path(user)
 492     assert_response :success
 493     assert_template :account
 494     assert_select ".notice", /^User information updated successfully/
 495     assert_select "form#accountForm > div.form-group > select#user_preferred_editor > option[selected][value=?]", "id"
 496
 497     # Changing to the default editor should work
 498     user.preferred_editor = "default"
 499     post user_account_path(user), :params => { :user => user.attributes }
 500     assert_response :redirect
 501     assert_redirected_to user_account_url(user)
 502     get user_account_path(user)
 503     assert_response :success
 504     assert_template :account
 505     assert_select ".notice", /^User information updated successfully/
 506     assert_select "form#accountForm > div.form-group > select#user_preferred_editor > option[selected]", false
 507
 508     # Changing to an uploaded image should work
 509     image = Rack::Test::UploadedFile.new("test/gpx/fixtures/a.gif", "image/gif")
 510     post user_account_path(user), :params => { :avatar_action => "new", :user => user.attributes.merge(:avatar => image) }
 511     assert_response :redirect
 512     assert_redirected_to user_account_url(user)
 513     get user_account_path(user)
 514     assert_response :success
 515     assert_template :account
 516     assert_select ".notice", /^User information updated successfully/
 517     assert_select "form#accountForm > fieldset.form-group > div.form-row > div.col-sm-10 > div.form-check > input[name=avatar_action][checked][value=?]", "keep"
 518
 519     # Changing to a gravatar image should work
 520     post user_account_path(user), :params => { :avatar_action => "gravatar", :user => user.attributes }
 521     assert_response :redirect
 522     assert_redirected_to user_account_url(user)
 523     get user_account_path(user)
 524     assert_response :success
 525     assert_template :account
 526     assert_select ".notice", /^User information updated successfully/
 527     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"
 528
 529     # Removing the image should work
 530     post user_account_path(user), :params => { :avatar_action => "delete", :user => user.attributes }
 531     assert_response :redirect
 532     assert_redirected_to user_account_url(user)
 533     get user_account_path(user)
 534     assert_response :success
 535     assert_template :account
 536     assert_select ".notice", /^User information updated successfully/
 537     assert_select "form#accountForm > fieldset.form-group > div.form-row > div.col-sm-10 > div.form-check > input[name=avatar_action][checked]", false
 538     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
 539
 540     # Adding external authentication should redirect to the auth provider
 541     post user_account_path(user), :params => { :user => user.attributes.merge(:auth_provider => "openid", :auth_uid => "gmail.com") }
 542     assert_response :redirect
 543     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")
 544
 545     # Changing name to one that exists should fail
 546     new_attributes = user.attributes.dup.merge(:display_name => create(:user).display_name)
 547     post user_account_path(user), :params => { :user => new_attributes }
 548     assert_response :success
 549     assert_template :account
 550     assert_select ".notice", false
 551     assert_select "form#accountForm > div.form-group > input.is-invalid#user_display_name"
 552
 553     # Changing name to one that exists should fail, regardless of case
 554     new_attributes = user.attributes.dup.merge(:display_name => create(:user).display_name.upcase)
 555     post user_account_path(user), :params => { :user => new_attributes }
 556     assert_response :success
 557     assert_template :account
 558     assert_select ".notice", false
 559     assert_select "form#accountForm > div.form-group > input.is-invalid#user_display_name"
 560
 561     # Changing name to one that doesn't exist should work
 562     new_attributes = user.attributes.dup.merge(:display_name => "new tester")
 563     post user_account_path(user), :params => { :user => new_attributes }
 564     assert_response :redirect
 565     assert_redirected_to user_account_url(:display_name => "new tester")
 566     get user_account_path(:display_name => "new tester")
 567     assert_response :success
 568     assert_template :account
 569     assert_select ".notice", /^User information updated successfully/
 570     assert_select "form#accountForm > div.form-group > input#user_display_name[value=?]", "new tester"
 571
 572     # Record the change of name
 573     user.display_name = "new tester"
 574
 575     # Changing email to one that exists should fail
 576     user.new_email = create(:user).email
 577     assert_no_difference "ActionMailer::Base.deliveries.size" do
 578       perform_enqueued_jobs do
 579         post user_account_path(user), :params => { :user => user.attributes }
 580       end
 581     end
 582     assert_response :success
 583     assert_template :account
 584     assert_select ".notice", false
 585     assert_select "form#accountForm > div.form-group > input.is-invalid#user_new_email"
 586
 587     # Changing email to one that exists should fail, regardless of case
 588     user.new_email = create(:user).email.upcase
 589     assert_no_difference "ActionMailer::Base.deliveries.size" do
 590       perform_enqueued_jobs do
 591         post user_account_path(user), :params => { :user => user.attributes }
 592       end
 593     end
 594     assert_response :success
 595     assert_template :account
 596     assert_select ".notice", false
 597     assert_select "form#accountForm > div.form-group > input.is-invalid#user_new_email"
 598
 599     # Changing email to one that doesn't exist should work
 600     user.new_email = "new_tester@example.com"
 601     assert_difference "ActionMailer::Base.deliveries.size", 1 do
 602       perform_enqueued_jobs do
 603         post user_account_path(user), :params => { :user => user.attributes }
 604       end
 605     end
 606     assert_response :redirect
 607     assert_redirected_to user_account_url(user)
 608     get user_account_path(user)
 609     assert_response :success
 610     assert_template :account
 611     assert_select ".notice", /^User information updated successfully/
 612     assert_select "form#accountForm > div.form-group > input#user_new_email[value=?]", user.new_email
 613     email = ActionMailer::Base.deliveries.first
 614     assert_equal 1, email.to.count
 615     assert_equal user.new_email, email.to.first
 616     ActionMailer::Base.deliveries.clear
 617   end
 618
 619   # Check that the user account page will display and contains some relevant
 620   # information for the user
 621   def test_show
 622     # Test a non-existent user
 623     get user_path(:display_name => "unknown")
 624     assert_response :not_found
 625
 626     # Test a normal user
 627     user = create(:user, :home_lon => 1.1, :home_lat => 1.1)
 628     friend_user = create(:user, :home_lon => 1.2, :home_lat => 1.2)
 629     create(:friendship, :befriender => user, :befriendee => friend_user)
 630     create(:changeset, :user => friend_user)
 631
 632     get user_path(user)
 633     assert_response :success
 634     assert_select "div#userinformation" do
 635       assert_select "a[href^='/user/#{ERB::Util.u(user.display_name)}/history']", 1
 636       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/traces']", 1
 637       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/diary']", 1
 638       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/diary/comments']", 1
 639       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/account']", 0
 640       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/blocks']", 0
 641       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/blocks_by']", 0
 642       assert_select "a[href='/blocks/new/#{ERB::Util.u(user.display_name)}']", 0
 643     end
 644
 645     # Friends shouldn't be visible as we're not logged in
 646     assert_select "div#friends-container", :count => 0
 647
 648     # Test a user who has been blocked
 649     blocked_user = create(:user)
 650     create(:user_block, :user => blocked_user)
 651     get user_path(blocked_user)
 652     assert_response :success
 653     assert_select "div#userinformation" do
 654       assert_select "a[href^='/user/#{ERB::Util.u(blocked_user.display_name)}/history']", 1
 655       assert_select "a[href='/user/#{ERB::Util.u(blocked_user.display_name)}/traces']", 1
 656       assert_select "a[href='/user/#{ERB::Util.u(blocked_user.display_name)}/diary']", 1
 657       assert_select "a[href='/user/#{ERB::Util.u(blocked_user.display_name)}/diary/comments']", 1
 658       assert_select "a[href='/user/#{ERB::Util.u(blocked_user.display_name)}/account']", 0
 659       assert_select "a[href='/user/#{ERB::Util.u(blocked_user.display_name)}/blocks']", 1
 660       assert_select "a[href='/user/#{ERB::Util.u(blocked_user.display_name)}/blocks_by']", 0
 661       assert_select "a[href='/blocks/new/#{ERB::Util.u(blocked_user.display_name)}']", 0
 662     end
 663
 664     # Test a moderator who has applied blocks
 665     moderator_user = create(:moderator_user)
 666     create(:user_block, :creator => moderator_user)
 667     get user_path(moderator_user)
 668     assert_response :success
 669     assert_select "div#userinformation" do
 670       assert_select "a[href^='/user/#{ERB::Util.u(moderator_user.display_name)}/history']", 1
 671       assert_select "a[href='/user/#{ERB::Util.u(moderator_user.display_name)}/traces']", 1
 672       assert_select "a[href='/user/#{ERB::Util.u(moderator_user.display_name)}/diary']", 1
 673       assert_select "a[href='/user/#{ERB::Util.u(moderator_user.display_name)}/diary/comments']", 1
 674       assert_select "a[href='/user/#{ERB::Util.u(moderator_user.display_name)}/account']", 0
 675       assert_select "a[href='/user/#{ERB::Util.u(moderator_user.display_name)}/blocks']", 0
 676       assert_select "a[href='/user/#{ERB::Util.u(moderator_user.display_name)}/blocks_by']", 1
 677       assert_select "a[href='/blocks/new/#{ERB::Util.u(moderator_user.display_name)}']", 0
 678     end
 679
 680     # Login as a normal user
 681     session_for(user)
 682
 683     # Test the normal user
 684     get user_path(user)
 685     assert_response :success
 686     assert_select "div#userinformation" do
 687       assert_select "a[href^='/user/#{ERB::Util.u(user.display_name)}/history']", 1
 688       assert_select "a[href='/traces/mine']", 1
 689       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/diary']", 1
 690       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/diary/comments']", 1
 691       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/account']", 1
 692       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/blocks']", 0
 693       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/blocks_by']", 0
 694       assert_select "a[href='/blocks/new/#{ERB::Util.u(user.display_name)}']", 0
 695     end
 696
 697     # Friends should be visible as we're now logged in
 698     assert_select "div#friends-container" do
 699       assert_select "div.contact-activity", :count => 1
 700     end
 701
 702     # Login as a moderator
 703     session_for(create(:moderator_user))
 704
 705     # Test the normal user
 706     get user_path(user)
 707     assert_response :success
 708     assert_select "div#userinformation" do
 709       assert_select "a[href^='/user/#{ERB::Util.u(user.display_name)}/history']", 1
 710       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/traces']", 1
 711       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/diary']", 1
 712       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/diary/comments']", 1
 713       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/account']", 0
 714       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/blocks']", 0
 715       assert_select "a[href='/user/#{ERB::Util.u(user.display_name)}/blocks_by']", 0
 716       assert_select "a[href='/blocks/new/#{ERB::Util.u(user.display_name)}']", 1
 717     end
 718   end
 719
 720   # Test whether information about contributor terms is shown for users who haven't agreed
 721   def test_terms_not_agreed
 722     agreed_user = create(:user, :terms_agreed => 3.days.ago)
 723     seen_user = create(:user, :terms_seen => true, :terms_agreed => nil)
 724     not_seen_user = create(:user, :terms_seen => false, :terms_agreed => nil)
 725
 726     get user_path(agreed_user)
 727     assert_response :success
 728     assert_select "div#userinformation" do
 729       assert_select "p", :count => 0, :text => /Contributor terms/
 730     end
 731
 732     get user_path(seen_user)
 733     assert_response :success
 734     # put @response.body
 735     assert_select "div#userinformation" do
 736       assert_select "p", :count => 1, :text => /Contributor terms/
 737       assert_select "p", /Declined/
 738     end
 739
 740     get user_path(not_seen_user)
 741     assert_response :success
 742     assert_select "div#userinformation" do
 743       assert_select "p", :count => 1, :text => /Contributor terms/
 744       assert_select "p", /Undecided/
 745     end
 746   end
 747
 748   def test_set_status
 749     user = create(:user)
 750
 751     # Try without logging in
 752     post set_status_user_path(user), :params => { :status => "suspended" }
 753     assert_response :forbidden
 754
 755     # Now try as a normal user
 756     session_for(user)
 757     post set_status_user_path(user), :params => { :status => "suspended" }
 758     assert_response :redirect
 759     assert_redirected_to :controller => :errors, :action => :forbidden
 760
 761     # Finally try as an administrator
 762     session_for(create(:administrator_user))
 763     post set_status_user_path(user), :params => { :status => "suspended" }
 764     assert_response :redirect
 765     assert_redirected_to :action => :show, :display_name => user.display_name
 766     assert_equal "suspended", User.find(user.id).status
 767   end
 768
 769   def test_destroy
 770     user = create(:user, :home_lat => 12.1, :home_lon => 12.1, :description => "test")
 771
 772     # Try without logging in
 773     delete user_path(user), :params => { :status => "suspended" }
 774     assert_response :forbidden
 775
 776     # Now try as a normal user
 777     session_for(user)
 778     delete user_path(user), :params => { :status => "suspended" }
 779     assert_response :redirect
 780     assert_redirected_to :controller => :errors, :action => :forbidden
 781
 782     # Finally try as an administrator
 783     session_for(create(:administrator_user))
 784     delete user_path(user), :params => { :status => "suspended" }
 785     assert_response :redirect
 786     assert_redirected_to :action => :show, :display_name => user.display_name
 787
 788     # Check that the user was deleted properly
 789     user.reload
 790     assert_equal "user_#{user.id}", user.display_name
 791     assert_equal "", user.description
 792     assert_nil user.home_lat
 793     assert_nil user.home_lon
 794     assert_not user.avatar.attached?
 795     assert_not user.email_valid
 796     assert_nil user.new_email
 797     assert_nil user.auth_provider
 798     assert_nil user.auth_uid
 799     assert_equal "deleted", user.status
 800   end
 801
 802   def test_index_get
 803     user = create(:user)
 804     moderator_user = create(:moderator_user)
 805     administrator_user = create(:administrator_user)
 806     _suspended_user = create(:user, :suspended)
 807     _ip_user = create(:user, :creation_ip => "1.2.3.4")
 808
 809     # There are now 7 users - the five above, plus two extra "granters" for the
 810     # moderator_user and administrator_user
 811     assert_equal 7, User.count
 812
 813     # Shouldn't work when not logged in
 814     get users_path
 815     assert_response :redirect
 816     assert_redirected_to login_path(:referer => users_path)
 817
 818     session_for(user)
 819
 820     # Shouldn't work when logged in as a normal user
 821     get users_path
 822     assert_response :redirect
 823     assert_redirected_to :controller => :errors, :action => :forbidden
 824
 825     session_for(moderator_user)
 826
 827     # Shouldn't work when logged in as a moderator
 828     get users_path
 829     assert_response :redirect
 830     assert_redirected_to :controller => :errors, :action => :forbidden
 831
 832     session_for(administrator_user)
 833
 834     # Note there is a header row, so all row counts are users + 1
 835     # Should work when logged in as an administrator
 836     get users_path
 837     assert_response :success
 838     assert_template :index
 839     assert_select "table#user_list tr", :count => 7 + 1
 840
 841     # Should be able to limit by status
 842     get users_path, :params => { :status => "suspended" }
 843     assert_response :success
 844     assert_template :index
 845     assert_select "table#user_list tr", :count => 1 + 1
 846
 847     # Should be able to limit by IP address
 848     get users_path, :params => { :ip => "1.2.3.4" }
 849     assert_response :success
 850     assert_template :index
 851     assert_select "table#user_list tr", :count => 1 + 1
 852   end
 853
 854   def test_index_get_paginated
 855     1.upto(100).each do |n|
 856       User.create(:display_name => "extra_#{n}",
 857                   :email => "extra#{n}@example.com",
 858                   :pass_crypt => "extraextra")
 859     end
 860
 861     session_for(create(:administrator_user))
 862
 863     # 100 examples, an administrator, and a granter for the admin.
 864     assert_equal 102, User.count
 865
 866     get users_path
 867     assert_response :success
 868     assert_template :index
 869     assert_select "table#user_list tr", :count => 51
 870
 871     get users_path, :params => { :page => 2 }
 872     assert_response :success
 873     assert_template :index
 874     assert_select "table#user_list tr", :count => 51
 875
 876     get users_path, :params => { :page => 3 }
 877     assert_response :success
 878     assert_template :index
 879     assert_select "table#user_list tr", :count => 3
 880   end
 881
 882   def test_index_post_confirm
 883     inactive_user = create(:user, :pending)
 884     suspended_user = create(:user, :suspended)
 885
 886     # Shouldn't work when not logged in
 887     assert_no_difference "User.active.count" do
 888       post users_path, :params => { :confirm => 1, :user => { inactive_user.id => 1, suspended_user.id => 1 } }
 889     end
 890     assert_response :forbidden
 891
 892     assert_equal "pending", inactive_user.reload.status
 893     assert_equal "suspended", suspended_user.reload.status
 894
 895     session_for(create(:user))
 896
 897     # Shouldn't work when logged in as a normal user
 898     assert_no_difference "User.active.count" do
 899       post users_path, :params => { :confirm => 1, :user => { inactive_user.id => 1, suspended_user.id => 1 } }
 900     end
 901     assert_response :redirect
 902     assert_redirected_to :controller => :errors, :action => :forbidden
 903     assert_equal "pending", inactive_user.reload.status
 904     assert_equal "suspended", suspended_user.reload.status
 905
 906     session_for(create(:moderator_user))
 907
 908     # Shouldn't work when logged in as a moderator
 909     assert_no_difference "User.active.count" do
 910       post users_path, :params => { :confirm => 1, :user => { inactive_user.id => 1, suspended_user.id => 1 } }
 911     end
 912     assert_response :redirect
 913     assert_redirected_to :controller => :errors, :action => :forbidden
 914     assert_equal "pending", inactive_user.reload.status
 915     assert_equal "suspended", suspended_user.reload.status
 916
 917     session_for(create(:administrator_user))
 918
 919     # Should work when logged in as an administrator
 920     assert_difference "User.active.count", 2 do
 921       post users_path, :params => { :confirm => 1, :user => { inactive_user.id => 1, suspended_user.id => 1 } }
 922     end
 923     assert_response :redirect
 924     assert_redirected_to :action => :index
 925     assert_equal "confirmed", inactive_user.reload.status
 926     assert_equal "confirmed", suspended_user.reload.status
 927   end
 928
 929   def test_index_post_hide
 930     normal_user = create(:user)
 931     confirmed_user = create(:user, :confirmed)
 932
 933     # Shouldn't work when not logged in
 934     assert_no_difference "User.active.count" do
 935       post users_path, :params => { :hide => 1, :user => { normal_user.id => 1, confirmed_user.id => 1 } }
 936     end
 937     assert_response :forbidden
 938
 939     assert_equal "active", normal_user.reload.status
 940     assert_equal "confirmed", confirmed_user.reload.status
 941
 942     session_for(create(:user))
 943
 944     # Shouldn't work when logged in as a normal user
 945     assert_no_difference "User.active.count" do
 946       post users_path, :params => { :hide => 1, :user => { normal_user.id => 1, confirmed_user.id => 1 } }
 947     end
 948     assert_response :redirect
 949     assert_redirected_to :controller => :errors, :action => :forbidden
 950     assert_equal "active", normal_user.reload.status
 951     assert_equal "confirmed", confirmed_user.reload.status
 952
 953     session_for(create(:moderator_user))
 954
 955     # Shouldn't work when logged in as a moderator
 956     assert_no_difference "User.active.count" do
 957       post users_path, :params => { :hide => 1, :user => { normal_user.id => 1, confirmed_user.id => 1 } }
 958     end
 959     assert_response :redirect
 960     assert_redirected_to :controller => :errors, :action => :forbidden
 961     assert_equal "active", normal_user.reload.status
 962     assert_equal "confirmed", confirmed_user.reload.status
 963
 964     session_for(create(:administrator_user))
 965
 966     # Should work when logged in as an administrator
 967     assert_difference "User.active.count", -2 do
 968       post users_path, :params => { :hide => 1, :user => { normal_user.id => 1, confirmed_user.id => 1 } }
 969     end
 970     assert_response :redirect
 971     assert_redirected_to :action => :index
 972     assert_equal "deleted", normal_user.reload.status
 973     assert_equal "deleted", confirmed_user.reload.status
 974   end
 975 end