test/controllers/user_controller_test.rb

   1 require "test_helper"
   2
   3 class UserControllerTest < ActionController::TestCase
   4   api_fixtures
   5   fixtures :messages, :friends
   6
   7   ##
   8   # test all routes which lead to this controller
   9   def test_routes
  10     assert_routing(
  11       { :path => "/api/0.6/user/1", :method => :get },
  12       { :controller => "user", :action => "api_read", :id => "1" }
  13     )
  14     assert_routing(
  15       { :path => "/api/0.6/user/details", :method => :get },
  16       { :controller => "user", :action => "api_details" }
  17     )
  18     assert_routing(
  19       { :path => "/api/0.6/user/gpx_files", :method => :get },
  20       { :controller => "user", :action => "api_gpx_files" }
  21     )
  22
  23     assert_routing(
  24       { :path => "/login", :method => :get },
  25       { :controller => "user", :action => "login" }
  26     )
  27     assert_routing(
  28       { :path => "/login", :method => :post },
  29       { :controller => "user", :action => "login" }
  30     )
  31     assert_recognizes(
  32       { :controller => "user", :action => "login", :format => "html" },
  33       { :path => "/login.html", :method => :get }
  34     )
  35
  36     assert_routing(
  37       { :path => "/logout", :method => :get },
  38       { :controller => "user", :action => "logout" }
  39     )
  40     assert_routing(
  41       { :path => "/logout", :method => :post },
  42       { :controller => "user", :action => "logout" }
  43     )
  44     assert_recognizes(
  45       { :controller => "user", :action => "logout", :format => "html" },
  46       { :path => "/logout.html", :method => :get }
  47     )
  48
  49     assert_routing(
  50       { :path => "/user/new", :method => :get },
  51       { :controller => "user", :action => "new" }
  52     )
  53
  54     assert_routing(
  55       { :path => "/user/new", :method => :post },
  56       { :controller => "user", :action => "create" }
  57     )
  58
  59     assert_routing(
  60       { :path => "/user/terms", :method => :get },
  61       { :controller => "user", :action => "terms" }
  62     )
  63
  64     assert_routing(
  65       { :path => "/user/save", :method => :post },
  66       { :controller => "user", :action => "save" }
  67     )
  68
  69     assert_routing(
  70       { :path => "/user/username/confirm", :method => :get },
  71       { :controller => "user", :action => "confirm", :display_name => "username" }
  72     )
  73     assert_routing(
  74       { :path => "/user/username/confirm", :method => :post },
  75       { :controller => "user", :action => "confirm", :display_name => "username" }
  76     )
  77     assert_routing(
  78       { :path => "/user/username/confirm/resend", :method => :get },
  79       { :controller => "user", :action => "confirm_resend", :display_name => "username" }
  80     )
  81
  82     assert_routing(
  83       { :path => "/user/confirm", :method => :get },
  84       { :controller => "user", :action => "confirm" }
  85     )
  86     assert_routing(
  87       { :path => "/user/confirm", :method => :post },
  88       { :controller => "user", :action => "confirm" }
  89     )
  90     assert_routing(
  91       { :path => "/user/confirm-email", :method => :get },
  92       { :controller => "user", :action => "confirm_email" }
  93     )
  94     assert_routing(
  95       { :path => "/user/confirm-email", :method => :post },
  96       { :controller => "user", :action => "confirm_email" }
  97     )
  98
  99     assert_routing(
 100       { :path => "/user/go_public", :method => :post },
 101       { :controller => "user", :action => "go_public" }
 102     )
 103
 104     assert_routing(
 105       { :path => "/user/forgot-password", :method => :get },
 106       { :controller => "user", :action => "lost_password" }
 107     )
 108     assert_routing(
 109       { :path => "/user/forgot-password", :method => :post },
 110       { :controller => "user", :action => "lost_password" }
 111     )
 112     assert_routing(
 113       { :path => "/user/reset-password", :method => :get },
 114       { :controller => "user", :action => "reset_password" }
 115     )
 116     assert_routing(
 117       { :path => "/user/reset-password", :method => :post },
 118       { :controller => "user", :action => "reset_password" }
 119     )
 120
 121     assert_routing(
 122       { :path => "/user/suspended", :method => :get },
 123       { :controller => "user", :action => "suspended" }
 124     )
 125
 126     assert_routing(
 127       { :path => "/user/username", :method => :get },
 128       { :controller => "user", :action => "view", :display_name => "username" }
 129     )
 130
 131     assert_routing(
 132       { :path => "/user/username/account", :method => :get },
 133       { :controller => "user", :action => "account", :display_name => "username" }
 134     )
 135     assert_routing(
 136       { :path => "/user/username/account", :method => :post },
 137       { :controller => "user", :action => "account", :display_name => "username" }
 138     )
 139
 140     assert_routing(
 141       { :path => "/user/username/make_friend", :method => :get },
 142       { :controller => "user", :action => "make_friend", :display_name => "username" }
 143     )
 144     assert_routing(
 145       { :path => "/user/username/make_friend", :method => :post },
 146       { :controller => "user", :action => "make_friend", :display_name => "username" }
 147     )
 148     assert_routing(
 149       { :path => "/user/username/remove_friend", :method => :get },
 150       { :controller => "user", :action => "remove_friend", :display_name => "username" }
 151     )
 152     assert_routing(
 153       { :path => "/user/username/remove_friend", :method => :post },
 154       { :controller => "user", :action => "remove_friend", :display_name => "username" }
 155     )
 156
 157     assert_routing(
 158       { :path => "/user/username/set_status", :method => :get },
 159       { :controller => "user", :action => "set_status", :display_name => "username" }
 160     )
 161     assert_routing(
 162       { :path => "/user/username/delete", :method => :get },
 163       { :controller => "user", :action => "delete", :display_name => "username" }
 164     )
 165
 166     assert_routing(
 167       { :path => "/users", :method => :get },
 168       { :controller => "user", :action => "list" }
 169     )
 170     assert_routing(
 171       { :path => "/users", :method => :post },
 172       { :controller => "user", :action => "list" }
 173     )
 174     assert_routing(
 175       { :path => "/users/status", :method => :get },
 176       { :controller => "user", :action => "list", :status => "status" }
 177     )
 178     assert_routing(
 179       { :path => "/users/status", :method => :post },
 180       { :controller => "user", :action => "list", :status => "status" }
 181     )
 182   end
 183
 184   # The user creation page loads
 185   def test_new_view
 186     get :new
 187     assert_response :redirect
 188     assert_redirected_to user_new_path(:cookie_test => "true")
 189
 190     get :new, { :cookie_test => "true" }, { :cookie_test => true }
 191     assert_response :success
 192
 193     assert_select "html", :count => 1 do
 194       assert_select "head", :count => 1 do
 195         assert_select "title", :text => /Sign Up/, :count => 1
 196       end
 197       assert_select "body", :count => 1 do
 198         assert_select "div#content", :count => 1 do
 199           assert_select "form[action='/user/new'][method='post']", :count => 1 do
 200             assert_select "input[id='user_email']", :count => 1
 201             assert_select "input[id='user_email_confirmation']", :count => 1
 202             assert_select "input[id='user_display_name']", :count => 1
 203             assert_select "input[id='user_pass_crypt'][type='password']", :count => 1
 204             assert_select "input[id='user_pass_crypt_confirmation'][type='password']", :count => 1
 205             assert_select "input[type='submit'][value='Sign Up']", :count => 1
 206           end
 207         end
 208       end
 209     end
 210   end
 211
 212   def test_new_success
 213     user = new_user
 214
 215     assert_difference "User.count", 1 do
 216       assert_difference "ActionMailer::Base.deliveries.size", 1 do
 217         post :save, {}, { :new_user => user }
 218       end
 219     end
 220
 221     # Check the e-mail
 222     register_email = ActionMailer::Base.deliveries.first
 223
 224     assert_equal register_email.to[0], user.email
 225     assert_match /#{@url}/, register_email.body.to_s
 226
 227     # Check the page
 228     assert_redirected_to :action => "confirm", :display_name => user.display_name
 229
 230     ActionMailer::Base.deliveries.clear
 231   end
 232
 233   def test_new_duplicate_email
 234     user = new_user
 235     user.email = users(:public_user).email
 236
 237     assert_no_difference "User.count" do
 238       assert_no_difference "ActionMailer::Base.deliveries.size" do
 239         post :save, {}, { :new_user => user }
 240       end
 241     end
 242
 243     assert_response :success
 244     assert_template "new"
 245     assert_select "form > fieldset > div.form-row > input.field_with_errors#user_email"
 246   end
 247
 248   def test_new_duplicate_email_uppercase
 249     user = new_user
 250     user.email = users(:public_user).email.upcase
 251
 252     assert_no_difference "User.count" do
 253       assert_no_difference "ActionMailer::Base.deliveries.size" do
 254         post :save, {}, { :new_user => user }
 255       end
 256     end
 257
 258     assert_response :success
 259     assert_template "new"
 260     assert_select "form > fieldset > div.form-row > input.field_with_errors#user_email"
 261   end
 262
 263   def test_new_duplicate_name
 264     user = new_user
 265     user.display_name = users(:public_user).display_name
 266
 267     assert_no_difference "User.count" do
 268       assert_no_difference "ActionMailer::Base.deliveries.size" do
 269         post :save, {}, { :new_user => user }
 270       end
 271     end
 272
 273     assert_response :success
 274     assert_template "new"
 275     assert_select "form > fieldset > div.form-row > input.field_with_errors#user_display_name"
 276   end
 277
 278   def test_new_duplicate_name_uppercase
 279     user = new_user
 280     user.display_name = users(:public_user).display_name.upcase
 281
 282     assert_no_difference "User.count" do
 283       assert_no_difference "ActionMailer::Base.deliveries.size" do
 284         post :save, {}, { :new_user => user }
 285       end
 286     end
 287
 288     assert_response :success
 289     assert_template "new"
 290     assert_select "form > fieldset > div.form-row > input.field_with_errors#user_display_name"
 291   end
 292
 293   def test_save_referer_params
 294     user = new_user
 295
 296     assert_difference "User.count", 1 do
 297       assert_difference "ActionMailer::Base.deliveries.size", 1 do
 298         post :save, {}, { :new_user => user,
 299                           :referer => "/edit?editor=id#map=1/2/3" }
 300       end
 301     end
 302
 303     assert_equal welcome_path(:editor => "id", :zoom => 1, :lat => 2, :lon => 3),
 304                  user.tokens.order("id DESC").first.referer
 305
 306     ActionMailer::Base.deliveries.clear
 307   end
 308
 309   def test_logout_without_referer
 310     get :logout
 311     assert_response :success
 312     assert_template :logout
 313     assert_select "input[name=referer][value=?]", ""
 314
 315     session_id = assert_select("input[name=session]").first["value"]
 316
 317     get :logout, :session => session_id
 318     assert_response :redirect
 319     assert_redirected_to root_path
 320   end
 321
 322   def test_logout_with_referer
 323     get :logout, :referer => "/test"
 324     assert_response :success
 325     assert_template :logout
 326     assert_select "input[name=referer][value=?]", "/test"
 327
 328     session_id = assert_select("input[name=session]").first["value"]
 329
 330     get :logout, :session => session_id, :referer => "/test"
 331     assert_response :redirect
 332     assert_redirected_to "/test"
 333   end
 334
 335   def test_confirm_get
 336     user = users(:inactive_user)
 337     confirm_string = user.tokens.create.token
 338
 339     @request.cookies["_osm_session"] = user.display_name
 340     get :confirm, :display_name => user.display_name, :confirm_string => confirm_string
 341     assert_response :success
 342     assert_template :confirm
 343   end
 344
 345   def test_confirm_get_already_confirmed
 346     user = users(:normal_user)
 347     confirm_string = user.tokens.create.token
 348
 349     @request.cookies["_osm_session"] = user.display_name
 350     get :confirm, :display_name => user.display_name, :confirm_string => confirm_string
 351     assert_response :redirect
 352     assert_redirected_to root_path
 353   end
 354
 355   def test_confirm_success_no_token_no_referer
 356     user = users(:inactive_user)
 357     confirm_string = user.tokens.create.token
 358
 359     @request.cookies["_osm_session"] = user.display_name
 360     post :confirm, :display_name => user.display_name, :confirm_string => confirm_string
 361     assert_redirected_to login_path
 362     assert_match /Confirmed your account/, flash[:notice]
 363   end
 364
 365   def test_confirm_success_good_token_no_referer
 366     user = users(:inactive_user)
 367     confirm_string = user.tokens.create.token
 368     token = user.tokens.create.token
 369
 370     @request.cookies["_osm_session"] = user.display_name
 371     post :confirm, { :display_name => user.display_name, :confirm_string => confirm_string }, { :token => token }
 372     assert_redirected_to welcome_path
 373   end
 374
 375   def test_confirm_success_bad_token_no_referer
 376     user = users(:inactive_user)
 377     confirm_string = user.tokens.create.token
 378     token = users(:normal_user).tokens.create.token
 379
 380     @request.cookies["_osm_session"] = user.display_name
 381     post :confirm, { :display_name => user.display_name, :confirm_string => confirm_string }, { :token => token }
 382     assert_redirected_to login_path
 383     assert_match /Confirmed your account/, flash[:notice]
 384   end
 385
 386   def test_confirm_success_no_token_with_referer
 387     user = users(:inactive_user)
 388     confirm_string = user.tokens.create(:referer => diary_new_path).token
 389
 390     @request.cookies["_osm_session"] = user.display_name
 391     post :confirm, :display_name => user.display_name, :confirm_string => confirm_string
 392     assert_redirected_to login_path(:referer => diary_new_path)
 393     assert_match /Confirmed your account/, flash[:notice]
 394   end
 395
 396   def test_confirm_success_good_token_with_referer
 397     user = users(:inactive_user)
 398     confirm_string = user.tokens.create(:referer => diary_new_path).token
 399     token = user.tokens.create.token
 400
 401     @request.cookies["_osm_session"] = user.display_name
 402     post :confirm, { :display_name => user.display_name, :confirm_string => confirm_string }, { :token => token }
 403     assert_redirected_to diary_new_path
 404   end
 405
 406   def test_confirm_success_bad_token_with_referer
 407     user = users(:inactive_user)
 408     confirm_string = user.tokens.create(:referer => diary_new_path).token
 409     token = users(:normal_user).tokens.create.token
 410
 411     @request.cookies["_osm_session"] = user.display_name
 412     post :confirm, { :display_name => user.display_name, :confirm_string => confirm_string }, { :token => token }
 413     assert_redirected_to login_path(:referer => diary_new_path)
 414     assert_match /Confirmed your account/, flash[:notice]
 415   end
 416
 417   def test_confirm_expired_token
 418     user = users(:inactive_user)
 419     confirm_string = user.tokens.create(:expiry => 1.day.ago).token
 420
 421     @request.cookies["_osm_session"] = user.display_name
 422     post :confirm, :display_name => user.display_name, :confirm_string => confirm_string
 423     assert_redirected_to :action => "confirm"
 424     assert_match /confirmation code has expired/, flash[:error]
 425   end
 426
 427   def test_confirm_already_confirmed
 428     user = users(:normal_user)
 429     confirm_string = user.tokens.create(:referer => diary_new_path).token
 430
 431     @request.cookies["_osm_session"] = user.display_name
 432     post :confirm, :display_name => user.display_name, :confirm_string => confirm_string
 433     assert_redirected_to :action => "login"
 434     assert_match /already been confirmed/, flash[:error]
 435   end
 436
 437   def test_confirm_resend_success
 438     assert_difference "ActionMailer::Base.deliveries.size", 1 do
 439       get :confirm_resend, :display_name => users(:inactive_user).display_name
 440     end
 441
 442     assert_response :redirect
 443     assert_redirected_to login_path
 444     assert_match /sent a new confirmation/, flash[:notice]
 445
 446     email = ActionMailer::Base.deliveries.last
 447
 448     assert_equal users(:inactive_user).email, email.to.first
 449
 450     ActionMailer::Base.deliveries.clear
 451   end
 452
 453   def test_confirm_resend_failure
 454     assert_no_difference "ActionMailer::Base.deliveries.size" do
 455       get :confirm_resend, :display_name => "No Such User"
 456     end
 457
 458     assert_response :redirect
 459     assert_redirected_to login_path
 460     assert_match "User No Such User not found.", flash[:error]
 461   end
 462
 463   def test_confirm_email_get
 464     user = users(:normal_user)
 465     confirm_string = user.tokens.create.token
 466
 467     get :confirm_email, :confirm_string => confirm_string
 468     assert_response :success
 469     assert_template :confirm_email
 470   end
 471
 472   def test_confirm_email_success
 473     user = users(:second_public_user)
 474     confirm_string = user.tokens.create.token
 475
 476     post :confirm_email, :confirm_string => confirm_string
 477     assert_response :redirect
 478     assert_redirected_to :action => :account, :display_name => user.display_name
 479     assert_match /Confirmed your change of email address/, flash[:notice]
 480   end
 481
 482   def test_confirm_email_already_confirmed
 483     user = users(:normal_user)
 484     confirm_string = user.tokens.create.token
 485
 486     post :confirm_email, :confirm_string => confirm_string
 487     assert_response :redirect
 488     assert_redirected_to :action => :account, :display_name => user.display_name
 489     assert_match /already been confirmed/, flash[:error]
 490   end
 491
 492   def test_confirm_email_bad_token
 493     post :confirm_email, :confirm_string => "XXXXX"
 494     assert_response :success
 495     assert_template :confirm_email
 496     assert_match /confirmation code has expired or does not exist/, flash[:error]
 497   end
 498
 499   def test_terms_new_user
 500     get :terms, {}, { :new_user => User.new }
 501     assert_response :success
 502     assert_template :terms
 503   end
 504
 505   def test_terms_seen
 506     user = users(:normal_user)
 507
 508     get :terms, {}, { :user => user }
 509     assert_response :redirect
 510     assert_redirected_to :action => :account, :display_name => user.display_name
 511   end
 512
 513   def test_terms_not_seen
 514     user = users(:terms_not_seen_user)
 515
 516     get :terms, {}, { :user => user }
 517     assert_response :success
 518     assert_template :terms
 519   end
 520
 521   def test_go_public
 522     post :go_public, {}, { :user => users(:normal_user) }
 523     assert_response :redirect
 524     assert_redirected_to :action => :account, :display_name => users(:normal_user).display_name
 525     assert_equal true, User.find(users(:normal_user).id).data_public
 526   end
 527
 528   def test_lost_password
 529     # Test fetching the lost password page
 530     get :lost_password
 531     assert_response :success
 532     assert_template :lost_password
 533     assert_select "div#notice", false
 534
 535     # Test resetting using the address as recorded for a user that has an
 536     # address which is duplicated in a different case by another user
 537     assert_difference "ActionMailer::Base.deliveries.size", 1 do
 538       post :lost_password, :user => { :email => users(:normal_user).email }
 539     end
 540     assert_response :redirect
 541     assert_redirected_to :action => :login
 542     assert_match /^Sorry you lost it/, flash[:notice]
 543     email = ActionMailer::Base.deliveries.first
 544     assert_equal 1, email.to.count
 545     assert_equal users(:normal_user).email, email.to.first
 546     ActionMailer::Base.deliveries.clear
 547
 548     # Test resetting using an address that matches a different user
 549     # that has the same address in a different case
 550     assert_difference "ActionMailer::Base.deliveries.size", 1 do
 551       post :lost_password, :user => { :email => users(:normal_user).email.upcase }
 552     end
 553     assert_response :redirect
 554     assert_redirected_to :action => :login
 555     assert_match /^Sorry you lost it/, flash[:notice]
 556     email = ActionMailer::Base.deliveries.first
 557     assert_equal 1, email.to.count
 558     assert_equal users(:uppercase_user).email, email.to.first
 559     ActionMailer::Base.deliveries.clear
 560
 561     # Test resetting using an address that is a case insensitive match
 562     # for more than one user but not an exact match for either
 563     assert_no_difference "ActionMailer::Base.deliveries.size" do
 564       post :lost_password, :user => { :email => users(:normal_user).email.titlecase }
 565     end
 566     assert_response :success
 567     assert_template :lost_password
 568     assert_select ".error", /^Could not find that email address/
 569
 570     # Test resetting using the address as recorded for a user that has an
 571     # address which is case insensitively unique
 572     assert_difference "ActionMailer::Base.deliveries.size", 1 do
 573       post :lost_password, :user => { :email => users(:public_user).email }
 574     end
 575     assert_response :redirect
 576     assert_redirected_to :action => :login
 577     assert_match /^Sorry you lost it/, flash[:notice]
 578     email = ActionMailer::Base.deliveries.first
 579     assert_equal 1, email.to.count
 580     assert_equal users(:public_user).email, email.to.first
 581     ActionMailer::Base.deliveries.clear
 582
 583     # Test resetting using an address that matches a user that has the
 584     # same (case insensitively unique) address in a different case
 585     assert_difference "ActionMailer::Base.deliveries.size", 1 do
 586       post :lost_password, :user => { :email => users(:public_user).email.upcase }
 587     end
 588     assert_response :redirect
 589     assert_redirected_to :action => :login
 590     assert_match /^Sorry you lost it/, flash[:notice]
 591     email = ActionMailer::Base.deliveries.first
 592     assert_equal 1, email.to.count
 593     assert_equal users(:public_user).email, email.to.first
 594     ActionMailer::Base.deliveries.clear
 595   end
 596
 597   def test_reset_password
 598     # Test a request with no token
 599     get :reset_password
 600     assert_response :bad_request
 601
 602     # Test a request with a bogus token
 603     get :reset_password, :token => "made_up_token"
 604     assert_response :redirect
 605     assert_redirected_to :action => :lost_password
 606
 607     # Create a valid token for a user
 608     token = User.find(users(:inactive_user).id).tokens.create
 609
 610     # Test a request with a valid token
 611     get :reset_password, :token => token.token
 612     assert_response :success
 613     assert_template :reset_password
 614
 615     # Test setting a new password
 616     post :reset_password, :token => token.token, :user => { :pass_crypt => "new_password", :pass_crypt_confirmation => "new_password" }
 617     assert_response :redirect
 618     assert_redirected_to :action => :login
 619     user = User.find(users(:inactive_user).id)
 620     assert_equal "active", user.status
 621     assert_equal true, user.email_valid
 622     assert_equal user, User.authenticate(:username => "inactive@openstreetmap.org", :password => "new_password")
 623   end
 624
 625   def test_account
 626     # Get a user to work with - note that this user deliberately
 627     # conflicts with uppercase_user in the email and display name
 628     # fields to test that we can change other fields without any
 629     # validation errors being reported
 630     user = users(:normal_user)
 631
 632     # Make sure that you are redirected to the login page when
 633     # you are not logged in
 634     get :account, :display_name => user.display_name
 635     assert_response :redirect
 636     assert_redirected_to :controller => :user, :action => "login", :referer => "/user/test/account"
 637
 638     # Make sure that you are blocked when not logged in as the right user
 639     get :account, { :display_name => user.display_name }, { "user" => users(:public_user).id }
 640     assert_response :forbidden
 641
 642     # Make sure we get the page when we are logged in as the right user
 643     get :account, { :display_name => user.display_name }, { "user" => user }
 644     assert_response :success
 645     assert_template :account
 646
 647     # Updating the description should work
 648     user.description = "new description"
 649     post :account, { :display_name => user.display_name, :user => user.attributes }, { "user" => user.id }
 650     assert_response :success
 651     assert_template :account
 652     assert_select "div#errorExplanation", false
 653     assert_select ".notice", /^User information updated successfully/
 654     assert_select "form#accountForm > fieldset > div.form-row > div#user_description_container > div#user_description_content > textarea#user_description", user.description
 655
 656     # Changing name to one that exists should fail
 657     new_attributes = user.attributes.dup.merge(:display_name => users(:public_user).display_name)
 658     post :account, { :display_name => user.display_name, :user => new_attributes }, { "user" => user.id }
 659     assert_response :success
 660     assert_template :account
 661     assert_select ".notice", false
 662     assert_select "div#errorExplanation"
 663     assert_select "form#accountForm > fieldset > div.form-row > input.field_with_errors#user_display_name"
 664
 665     # Changing name to one that exists should fail, regardless of case
 666     new_attributes = user.attributes.dup.merge(:display_name => users(:public_user).display_name.upcase)
 667     post :account, { :display_name => user.display_name, :user => new_attributes }, { "user" => user.id }
 668     assert_response :success
 669     assert_template :account
 670     assert_select ".notice", false
 671     assert_select "div#errorExplanation"
 672     assert_select "form#accountForm > fieldset > div.form-row > input.field_with_errors#user_display_name"
 673
 674     # Changing name to one that doesn't exist should work
 675     new_attributes = user.attributes.dup.merge(:display_name => "new tester")
 676     post :account, { :display_name => user.display_name, :user => new_attributes }, { "user" => user.id }
 677     assert_response :success
 678     assert_template :account
 679     assert_select "div#errorExplanation", false
 680     assert_select ".notice", /^User information updated successfully/
 681     assert_select "form#accountForm > fieldset > div.form-row > input#user_display_name[value=?]", "new tester"
 682
 683     # Record the change of name
 684     user.display_name = "new tester"
 685
 686     # Changing email to one that exists should fail
 687     user.new_email = users(:public_user).email
 688     assert_no_difference "ActionMailer::Base.deliveries.size" do
 689       post :account, { :display_name => user.display_name, :user => user.attributes }, { "user" => user.id }
 690     end
 691     assert_response :success
 692     assert_template :account
 693     assert_select ".notice", false
 694     assert_select "div#errorExplanation"
 695     assert_select "form#accountForm > fieldset > div.form-row > input.field_with_errors#user_new_email"
 696
 697     # Changing email to one that exists should fail, regardless of case
 698     user.new_email = users(:public_user).email.upcase
 699     assert_no_difference "ActionMailer::Base.deliveries.size" do
 700       post :account, { :display_name => user.display_name, :user => user.attributes }, { "user" => user.id }
 701     end
 702     assert_response :success
 703     assert_template :account
 704     assert_select ".notice", false
 705     assert_select "div#errorExplanation"
 706     assert_select "form#accountForm > fieldset > div.form-row > input.field_with_errors#user_new_email"
 707
 708     # Changing email to one that doesn't exist should work
 709     user.new_email = "new_tester@example.com"
 710     assert_difference "ActionMailer::Base.deliveries.size", 1 do
 711       post :account, { :display_name => user.display_name, :user => user.attributes }, { "user" => user.id }
 712     end
 713     assert_response :success
 714     assert_template :account
 715     assert_select "div#errorExplanation", false
 716     assert_select ".notice", /^User information updated successfully/
 717     assert_select "form#accountForm > fieldset > div.form-row > input#user_new_email[value=?]", user.new_email
 718     email = ActionMailer::Base.deliveries.first
 719     assert_equal 1, email.to.count
 720     assert_equal user.new_email, email.to.first
 721     ActionMailer::Base.deliveries.clear
 722   end
 723
 724   # Check that the user account page will display and contains some relevant
 725   # information for the user
 726   def test_view
 727     # Test a non-existent user
 728     get :view, :display_name => "unknown"
 729     assert_response :not_found
 730
 731     # Test a normal user
 732     get :view, :display_name => "test"
 733     assert_response :success
 734     assert_select "div#userinformation" do
 735       assert_select "a[href^='/user/test/history']", 1
 736       assert_select "a[href='/user/test/traces']", 1
 737       assert_select "a[href='/user/test/diary']", 1
 738       assert_select "a[href='/user/test/diary/comments']", 1
 739       assert_select "a[href='/user/test/account']", 0
 740       assert_select "a[href='/user/test/blocks']", 0
 741       assert_select "a[href='/user/test/blocks_by']", 0
 742       assert_select "a[href='/blocks/new/test']", 0
 743     end
 744
 745     # Test a user who has been blocked
 746     get :view, :display_name => "blocked"
 747     assert_response :success
 748     assert_select "div#userinformation" do
 749       assert_select "a[href^='/user/blocked/history']", 1
 750       assert_select "a[href='/user/blocked/traces']", 1
 751       assert_select "a[href='/user/blocked/diary']", 1
 752       assert_select "a[href='/user/blocked/diary/comments']", 1
 753       assert_select "a[href='/user/blocked/account']", 0
 754       assert_select "a[href='/user/blocked/blocks']", 1
 755       assert_select "a[href='/user/blocked/blocks_by']", 0
 756       assert_select "a[href='/blocks/new/blocked']", 0
 757     end
 758
 759     # Test a moderator who has applied blocks
 760     get :view, :display_name => "moderator"
 761     assert_response :success
 762     assert_select "div#userinformation" do
 763       assert_select "a[href^='/user/moderator/history']", 1
 764       assert_select "a[href='/user/moderator/traces']", 1
 765       assert_select "a[href='/user/moderator/diary']", 1
 766       assert_select "a[href='/user/moderator/diary/comments']", 1
 767       assert_select "a[href='/user/moderator/account']", 0
 768       assert_select "a[href='/user/moderator/blocks']", 0
 769       assert_select "a[href='/user/moderator/blocks_by']", 1
 770       assert_select "a[href='/blocks/new/moderator']", 0
 771     end
 772
 773     # Login as a normal user
 774     session[:user] = users(:normal_user).id
 775
 776     # Test the normal user
 777     get :view, :display_name => "test"
 778     assert_response :success
 779     assert_select "div#userinformation" do
 780       assert_select "a[href^='/user/test/history']", 1
 781       assert_select "a[href='/traces/mine']", 1
 782       assert_select "a[href='/user/test/diary']", 1
 783       assert_select "a[href='/user/test/diary/comments']", 1
 784       assert_select "a[href='/user/test/account']", 1
 785       assert_select "a[href='/user/test/blocks']", 0
 786       assert_select "a[href='/user/test/blocks_by']", 0
 787       assert_select "a[href='/blocks/new/test']", 0
 788     end
 789
 790     # Login as a moderator
 791     session[:user] = users(:moderator_user).id
 792
 793     # Test the normal user
 794     get :view, :display_name => "test"
 795     assert_response :success
 796     assert_select "div#userinformation" do
 797       assert_select "a[href^='/user/test/history']", 1
 798       assert_select "a[href='/user/test/traces']", 1
 799       assert_select "a[href='/user/test/diary']", 1
 800       assert_select "a[href='/user/test/diary/comments']", 1
 801       assert_select "a[href='/user/test/account']", 0
 802       assert_select "a[href='/user/test/blocks']", 0
 803       assert_select "a[href='/user/test/blocks_by']", 0
 804       assert_select "a[href='/blocks/new/test']", 1
 805     end
 806   end
 807
 808   def test_api_read
 809     # check that a visible user is returned properly
 810     get :api_read, :id => users(:normal_user).id
 811     assert_response :success
 812     assert_equal "text/xml", response.content_type
 813
 814     # check the data that is returned
 815     assert_select "description", :count => 1, :text => "test"
 816     assert_select "contributor-terms", :count => 1 do
 817       assert_select "[agreed='true']"
 818     end
 819     assert_select "img", :count => 1
 820     assert_select "roles", :count => 1 do
 821       assert_select "role", :count => 0
 822     end
 823     assert_select "changesets", :count => 1 do
 824       assert_select "[count='0']"
 825     end
 826     assert_select "traces", :count => 1 do
 827       assert_select "[count='0']"
 828     end
 829     assert_select "blocks", :count => 1 do
 830       assert_select "received", :count => 1 do
 831         assert_select "[count='0'][active='0']"
 832       end
 833       assert_select "issued", :count => 0
 834     end
 835
 836     # check that we aren't revealing private information
 837     assert_select "contributor-terms[pd]", false
 838     assert_select "home", false
 839     assert_select "languages", false
 840     assert_select "messages", false
 841
 842     # check that a suspended user is not returned
 843     get :api_read, :id => users(:suspended_user).id
 844     assert_response :gone
 845
 846     # check that a deleted user is not returned
 847     get :api_read, :id => users(:deleted_user).id
 848     assert_response :gone
 849
 850     # check that a non-existent user is not returned
 851     get :api_read, :id => 0
 852     assert_response :not_found
 853   end
 854
 855   def test_api_details
 856     # check that nothing is returned when not logged in
 857     get :api_details
 858     assert_response :unauthorized
 859
 860     # check that we get a response when logged in
 861     basic_authorization(users(:normal_user).email, "test")
 862     get :api_details
 863     assert_response :success
 864     assert_equal "text/xml", response.content_type
 865
 866     # check the data that is returned
 867     assert_select "description", :count => 1, :text => "test"
 868     assert_select "contributor-terms", :count => 1 do
 869       assert_select "[agreed='true'][pd='false']"
 870     end
 871     assert_select "img", :count => 1
 872     assert_select "roles", :count => 1 do
 873       assert_select "role", :count => 0
 874     end
 875     assert_select "changesets", :count => 1 do
 876       assert_select "[count='0']", :count => 1
 877     end
 878     assert_select "traces", :count => 1 do
 879       assert_select "[count='0']", :count => 1
 880     end
 881     assert_select "blocks", :count => 1 do
 882       assert_select "received", :count => 1 do
 883         assert_select "[count='0'][active='0']"
 884       end
 885       assert_select "issued", :count => 0
 886     end
 887     assert_select "home", :count => 1 do
 888       assert_select "[lat='12.1'][lon='12.1'][zoom='3']"
 889     end
 890     assert_select "languages", :count => 1 do
 891       assert_select "lang", :count => 1, :text => "en"
 892     end
 893     assert_select "messages", :count => 1 do
 894       assert_select "received", :count => 1 do
 895         assert_select "[count='1'][unread='0']"
 896       end
 897       assert_select "sent", :count => 1 do
 898         assert_select "[count='1']"
 899       end
 900     end
 901   end
 902
 903   def test_api_gpx_files
 904     # check that nothing is returned when not logged in
 905     get :api_gpx_files
 906     assert_response :unauthorized
 907
 908     # check that we get a response when logged in
 909     basic_authorization(users(:normal_user).email, "test")
 910     get :api_gpx_files
 911     assert_response :success
 912     assert_equal "text/xml", response.content_type
 913
 914     # check the data that is returned
 915     assert_select "gpx_file[id='1']", 1 do
 916       assert_select "tag", "London"
 917     end
 918     assert_select "gpx_file[id='4']", 1 do
 919       assert_select "tag", "Birmingham"
 920     end
 921   end
 922
 923   def test_make_friend
 924     # Get users to work with
 925     user = users(:normal_user)
 926     friend = users(:second_public_user)
 927
 928     # Check that the users aren't already friends
 929     assert_nil Friend.where(:user_id => user.id, :friend_user_id => friend.id).first
 930
 931     # When not logged in a GET should ask us to login
 932     get :make_friend, :display_name => friend.display_name
 933     assert_redirected_to :controller => :user, :action => "login", :referer => make_friend_path(:display_name => friend.display_name)
 934
 935     # When not logged in a POST should error
 936     post :make_friend, :display_name => friend.display_name
 937     assert_response :forbidden
 938     assert_nil Friend.where(:user_id => user.id, :friend_user_id => friend.id).first
 939
 940     # When logged in a GET should get a confirmation page
 941     get :make_friend, { :display_name => friend.display_name }, { :user => user.id }
 942     assert_response :success
 943     assert_template :make_friend
 944     assert_select "form" do
 945       assert_select "input[type='hidden'][name='referer']", 0
 946       assert_select "input[type='submit']", 1
 947     end
 948     assert_nil Friend.where(:user_id => user.id, :friend_user_id => friend.id).first
 949
 950     # When logged in a POST should add the friendship
 951     assert_difference "ActionMailer::Base.deliveries.size", 1 do
 952       post :make_friend, { :display_name => friend.display_name }, { :user => user.id }
 953     end
 954     assert_redirected_to user_path(:display_name => friend.display_name)
 955     assert_match /is now your friend/, flash[:notice]
 956     assert Friend.where(:user_id => user.id, :friend_user_id => friend.id).first
 957     email = ActionMailer::Base.deliveries.first
 958     assert_equal 1, email.to.count
 959     assert_equal friend.email, email.to.first
 960     ActionMailer::Base.deliveries.clear
 961
 962     # A second POST should report that the friendship already exists
 963     assert_no_difference "ActionMailer::Base.deliveries.size" do
 964       post :make_friend, { :display_name => friend.display_name }, { :user => user.id }
 965     end
 966     assert_redirected_to user_path(:display_name => friend.display_name)
 967     assert_match /You are already friends with/, flash[:warning]
 968     assert Friend.where(:user_id => user.id, :friend_user_id => friend.id).first
 969   end
 970
 971   def test_make_friend_with_referer
 972     # Get users to work with
 973     user = users(:normal_user)
 974     friend = users(:second_public_user)
 975
 976     # Check that the users aren't already friends
 977     assert_nil Friend.where(:user_id => user.id, :friend_user_id => friend.id).first
 978
 979     # The GET should preserve any referer
 980     get :make_friend, { :display_name => friend.display_name, :referer => "/test" }, { :user => user.id }
 981     assert_response :success
 982     assert_template :make_friend
 983     assert_select "form" do
 984       assert_select "input[type='hidden'][name='referer'][value='/test']", 1
 985       assert_select "input[type='submit']", 1
 986     end
 987     assert_nil Friend.where(:user_id => user.id, :friend_user_id => friend.id).first
 988
 989     # When logged in a POST should add the friendship and refer us
 990     assert_difference "ActionMailer::Base.deliveries.size", 1 do
 991       post :make_friend, { :display_name => friend.display_name, :referer => "/test" }, { :user => user.id }
 992     end
 993     assert_redirected_to "/test"
 994     assert_match /is now your friend/, flash[:notice]
 995     assert Friend.where(:user_id => user.id, :friend_user_id => friend.id).first
 996     email = ActionMailer::Base.deliveries.first
 997     assert_equal 1, email.to.count
 998     assert_equal friend.email, email.to.first
 999     ActionMailer::Base.deliveries.clear
1000   end
1001
1002   def test_make_friend_unkown_user
1003     # Should error when a bogus user is specified
1004     get :make_friend, { :display_name => "No Such User" }, { :user => users(:normal_user).id }
1005     assert_response :not_found
1006     assert_template :no_such_user
1007   end
1008
1009   def test_remove_friend
1010     # Get users to work with
1011     user = users(:normal_user)
1012     friend = users(:public_user)
1013
1014     # Check that the users are friends
1015     assert Friend.where(:user_id => user.id, :friend_user_id => friend.id).first
1016
1017     # When not logged in a GET should ask us to login
1018     get :remove_friend, :display_name => friend.display_name
1019     assert_redirected_to :controller => :user, :action => "login", :referer => remove_friend_path(:display_name => friend.display_name)
1020
1021     # When not logged in a POST should error
1022     post :remove_friend, :display_name => friend.display_name
1023     assert_response :forbidden
1024     assert Friend.where(:user_id => user.id, :friend_user_id => friend.id).first
1025
1026     # When logged in a GET should get a confirmation page
1027     get :remove_friend, { :display_name => friend.display_name }, { :user => user.id }
1028     assert_response :success
1029     assert_template :remove_friend
1030     assert_select "form" do
1031       assert_select "input[type='hidden'][name='referer']", 0
1032       assert_select "input[type='submit']", 1
1033     end
1034     assert Friend.where(:user_id => user.id, :friend_user_id => friend.id).first
1035
1036     # When logged in a POST should remove the friendship
1037     post :remove_friend, { :display_name => friend.display_name }, { :user => user.id }
1038     assert_redirected_to user_path(:display_name => friend.display_name)
1039     assert_match /was removed from your friends/, flash[:notice]
1040     assert_nil Friend.where(:user_id => user.id, :friend_user_id => friend.id).first
1041
1042     # A second POST should report that the friendship does not exist
1043     post :remove_friend, { :display_name => friend.display_name }, { :user => user.id }
1044     assert_redirected_to user_path(:display_name => friend.display_name)
1045     assert_match /is not one of your friends/, flash[:error]
1046     assert_nil Friend.where(:user_id => user.id, :friend_user_id => friend.id).first
1047   end
1048
1049   def test_remove_friend_with_referer
1050     # Get users to work with
1051     user = users(:normal_user)
1052     friend = users(:public_user)
1053
1054     # Check that the users are friends
1055     assert Friend.where(:user_id => user.id, :friend_user_id => friend.id).first
1056
1057     # The GET should preserve any referer
1058     get :remove_friend, { :display_name => friend.display_name, :referer => "/test" }, { :user => user.id }
1059     assert_response :success
1060     assert_template :remove_friend
1061     assert_select "form" do
1062       assert_select "input[type='hidden'][name='referer'][value='/test']", 1
1063       assert_select "input[type='submit']", 1
1064     end
1065     assert Friend.where(:user_id => user.id, :friend_user_id => friend.id).first
1066
1067     # When logged in a POST should remove the friendship and refer
1068     post :remove_friend, { :display_name => friend.display_name, :referer => "/test" }, { :user => user.id }
1069     assert_redirected_to "/test"
1070     assert_match /was removed from your friends/, flash[:notice]
1071     assert_nil Friend.where(:user_id => user.id, :friend_user_id => friend.id).first
1072   end
1073
1074   def test_remove_friend_unkown_user
1075     # Should error when a bogus user is specified
1076     get :remove_friend, { :display_name => "No Such User" }, { :user => users(:normal_user).id }
1077     assert_response :not_found
1078     assert_template :no_such_user
1079   end
1080
1081   def test_set_status
1082     # Try without logging in
1083     get :set_status, :display_name => users(:normal_user).display_name, :status => "suspended"
1084     assert_response :redirect
1085     assert_redirected_to :action => :login, :referer => set_status_user_path(:status => "suspended")
1086
1087     # Now try as a normal user
1088     get :set_status, { :display_name => users(:normal_user).display_name, :status => "suspended" }, { :user => users(:normal_user).id }
1089     assert_response :redirect
1090     assert_redirected_to :action => :view, :display_name => users(:normal_user).display_name
1091
1092     # Finally try as an administrator
1093     get :set_status, { :display_name => users(:normal_user).display_name, :status => "suspended" }, { :user => users(:administrator_user).id }
1094     assert_response :redirect
1095     assert_redirected_to :action => :view, :display_name => users(:normal_user).display_name
1096     assert_equal "suspended", User.find(users(:normal_user).id).status
1097   end
1098
1099   def test_delete
1100     # Try without logging in
1101     get :delete, :display_name => users(:normal_user).display_name, :status => "suspended"
1102     assert_response :redirect
1103     assert_redirected_to :action => :login, :referer => delete_user_path(:status => "suspended")
1104
1105     # Now try as a normal user
1106     get :delete, { :display_name => users(:normal_user).display_name, :status => "suspended" }, { :user => users(:normal_user).id }
1107     assert_response :redirect
1108     assert_redirected_to :action => :view, :display_name => users(:normal_user).display_name
1109
1110     # Finally try as an administrator
1111     get :delete, { :display_name => users(:normal_user).display_name, :status => "suspended" }, { :user => users(:administrator_user).id }
1112     assert_response :redirect
1113     assert_redirected_to :action => :view, :display_name => users(:normal_user).display_name
1114
1115     # Check that the user was deleted properly
1116     user = User.find(users(:normal_user).id)
1117     assert_equal "user_1", user.display_name
1118     assert_equal "", user.description
1119     assert_nil user.home_lat
1120     assert_nil user.home_lon
1121     assert_equal false, user.image.file?
1122     assert_equal false, user.email_valid
1123     assert_nil user.new_email
1124     assert_nil user.auth_provider
1125     assert_nil user.auth_uid
1126     assert_equal "deleted", user.status
1127   end
1128
1129   private
1130
1131   def new_user
1132     user = User.new
1133     user.status = "pending"
1134     user.display_name = "new_tester"
1135     user.email = "newtester@osm.org"
1136     user.email_confirmation = "newtester@osm.org"
1137     user.pass_crypt = "testtest"
1138     user.pass_crypt_confirmation = "testtest"
1139     user
1140   end
1141 end