test/integration/user_creation_test.rb

   1 require "test_helper"
   2
   3 class UserCreationTest < ActionDispatch::IntegrationTest
   4   def setup
   5     OmniAuth.config.test_mode = true
   6
   7     stub_request(:get, /.*gravatar.com.*d=404/).to_return(:status => 404)
   8   end
   9
  10   def teardown
  11     OmniAuth.config.mock_auth[:openid] = nil
  12     OmniAuth.config.mock_auth[:google] = nil
  13     OmniAuth.config.mock_auth[:facebook] = nil
  14     OmniAuth.config.mock_auth[:microsoft] = nil
  15     OmniAuth.config.mock_auth[:github] = nil
  16     OmniAuth.config.mock_auth[:wikipedia] = nil
  17     OmniAuth.config.test_mode = false
  18   end
  19
  20   def test_create_user_form
  21     get "/user/new"
  22     follow_redirect!
  23     assert_response :success
  24     assert_template "users/new"
  25   end
  26
  27   def test_user_create_submit_duplicate_email
  28     dup_email = create(:user).email
  29     display_name = "new_tester"
  30     assert_difference("User.count", 0) do
  31       assert_difference("ActionMailer::Base.deliveries.size", 0) do
  32         perform_enqueued_jobs do
  33           post "/user/new",
  34                :params => { :user => { :email => dup_email,
  35                                        :email_confirmation => dup_email,
  36                                        :display_name => display_name,
  37                                        :pass_crypt => "testtest",
  38                                        :pass_crypt_confirmation => "testtest" } }
  39         end
  40       end
  41     end
  42     assert_response :success
  43     assert_template "users/new"
  44     assert_select "form"
  45     assert_select "form > div > input.is-invalid#user_email"
  46   end
  47
  48   def test_user_create_submit_duplicate_username
  49     dup_display_name = create(:user).display_name
  50     email = "new_tester"
  51     assert_difference("User.count", 0) do
  52       assert_difference("ActionMailer::Base.deliveries.size", 0) do
  53         perform_enqueued_jobs do
  54           post "/user/new",
  55                :params => { :user => { :email => email,
  56                                        :email_confirmation => email,
  57                                        :display_name => dup_display_name,
  58                                        :pass_crypt => "testtest",
  59                                        :pass_crypt_confirmation => "testtest" } }
  60         end
  61       end
  62     end
  63     assert_response :success
  64     assert_template "users/new"
  65     assert_select "form > div > input.is-invalid#user_display_name"
  66   end
  67
  68   def test_user_create_success
  69     new_email = "newtester@osm.org"
  70     display_name = "new_tester"
  71
  72     assert_difference("User.count", 0) do
  73       assert_difference("ActionMailer::Base.deliveries.size", 0) do
  74         perform_enqueued_jobs do
  75           post "/user/new",
  76                :params => { :user => { :email => new_email,
  77                                        :email_confirmation => new_email,
  78                                        :display_name => display_name,
  79                                        :pass_crypt => "testtest",
  80                                        :pass_crypt_confirmation => "testtest" } }
  81         end
  82       end
  83     end
  84
  85     assert_redirected_to "/user/terms"
  86
  87     assert_difference("User.count") do
  88       assert_difference("ActionMailer::Base.deliveries.size", 1) do
  89         perform_enqueued_jobs do
  90           post "/user/save",
  91                :params => { :read_ct => 1, :read_tou => 1 }
  92           follow_redirect!
  93         end
  94       end
  95     end
  96
  97     assert_response :success
  98     assert_template "confirmations/confirm"
  99
 100     user = User.find_by(:email => "newtester@osm.org")
 101     assert_not_nil user
 102     assert_not_predicate user, :active?
 103
 104     register_email = ActionMailer::Base.deliveries.first
 105     assert_equal register_email.to.first, new_email
 106     found_confirmation_url = register_email.parts.first.parts.first.to_s =~ %r{\shttp://test.host(/\S+)\s}
 107     assert found_confirmation_url
 108     confirmation_url = Regexp.last_match(1)
 109     ActionMailer::Base.deliveries.clear
 110
 111     post confirmation_url
 112
 113     assert_response :redirect
 114     assert_redirected_to welcome_path
 115
 116     user.reload
 117     assert_predicate user, :active?
 118
 119     assert_equal user, User.authenticate(:username => new_email, :password => "testtest")
 120   end
 121
 122   def test_user_create_no_tou_failure
 123     new_email = "#newtester@osm.org"
 124     display_name = "new_tester"
 125
 126     assert_difference("User.count", 0) do
 127       assert_difference("ActionMailer::Base.deliveries.size", 0) do
 128         perform_enqueued_jobs do
 129           post "/user/new",
 130                :params => { :user => { :email => new_email,
 131                                        :email_confirmation => new_email,
 132                                        :display_name => display_name,
 133                                        :pass_crypt => "testtest",
 134                                        :pass_crypt_confirmation => "testtest" } }
 135         end
 136       end
 137     end
 138
 139     assert_redirected_to "/user/terms"
 140
 141     perform_enqueued_jobs do
 142       post "/user/save"
 143       assert_redirected_to "/user/terms"
 144     end
 145
 146     ActionMailer::Base.deliveries.clear
 147   end
 148
 149   # Check that the user can successfully recover their password
 150   def test_lost_password_recovery_success
 151     # Open the lost password form
 152     # Submit the lost password form
 153     # Check the e-mail
 154     # Submit the reset password token
 155     # Check that the password has changed, and the user can login
 156   end
 157
 158   def test_user_create_redirect
 159     new_email = "redirect_tester@osm.org"
 160     display_name = "redirect_tester"
 161     password = "testtest"
 162     # nothing special about this page, just need a protected page to redirect back to.
 163     referer = "/traces/mine"
 164     assert_difference("User.count") do
 165       assert_difference("ActionMailer::Base.deliveries.size", 1) do
 166         perform_enqueued_jobs do
 167           post "/user/new",
 168                :params => { :user => { :email => new_email,
 169                                        :email_confirmation => new_email,
 170                                        :display_name => display_name,
 171                                        :pass_crypt => password,
 172                                        :pass_crypt_confirmation => password },
 173                             :referer => referer }
 174           assert_redirected_to "/user/terms"
 175           post "/user/save",
 176                :params => { :user => { :email => new_email,
 177                                        :email_confirmation => new_email,
 178                                        :display_name => display_name,
 179                                        :pass_crypt => password,
 180                                        :pass_crypt_confirmation => password },
 181                             :read_ct => 1, :read_tou => 1 }
 182           follow_redirect!
 183         end
 184       end
 185     end
 186
 187     # Check the e-mail
 188     register_email = ActionMailer::Base.deliveries.first
 189
 190     assert_equal register_email.to.first, new_email
 191     # Check that the confirm account url is correct
 192     confirm_regex = Regexp.new("/user/redirect_tester/confirm\\?confirm_string=([a-zA-Z0-9_-]*)")
 193     email_text_parts(register_email).each do |part|
 194       assert_match confirm_regex, part.body.to_s
 195     end
 196     confirm_string = email_text_parts(register_email).first.body.match(confirm_regex)[1]
 197
 198     # Check the page
 199     assert_response :success
 200     assert_template "confirmations/confirm"
 201
 202     ActionMailer::Base.deliveries.clear
 203
 204     # Go to the confirmation page
 205     get "/user/#{display_name}/confirm", :params => { :confirm_string => confirm_string }
 206     assert_response :success
 207     assert_template "confirmations/confirm"
 208
 209     post "/user/#{display_name}/confirm", :params => { :confirm_string => confirm_string }
 210     assert_response :redirect
 211     follow_redirect!
 212     assert_response :success
 213     assert_template "site/welcome"
 214   end
 215
 216   def test_user_create_openid_success
 217     OmniAuth.config.add_mock(:openid, :uid => "http://localhost:1123/new.tester")
 218
 219     new_email = "newtester-openid@osm.org"
 220     display_name = "new_tester-openid"
 221     password = "testtest"
 222     assert_difference("User.count") do
 223       assert_difference("ActionMailer::Base.deliveries.size", 1) do
 224         perform_enqueued_jobs do
 225           post "/user/new",
 226                :params => { :user => { :email => new_email,
 227                                        :email_confirmation => new_email,
 228                                        :display_name => display_name,
 229                                        :auth_provider => "openid",
 230                                        :auth_uid => "http://localhost:1123/new.tester",
 231                                        :pass_crypt => "",
 232                                        :pass_crypt_confirmation => "" } }
 233           assert_response :redirect
 234           assert_redirected_to auth_path(:provider => "openid", :openid_url => "http://localhost:1123/new.tester", :origin => "/user/new")
 235           post response.location
 236           assert_response :redirect
 237           assert_redirected_to auth_success_path(:provider => "openid", :openid_url => "http://localhost:1123/new.tester", :origin => "/user/new")
 238           follow_redirect!
 239           assert_response :redirect
 240           assert_redirected_to "/user/terms"
 241           post "/user/save",
 242                :params => { :user => { :email => new_email,
 243                                        :email_confirmation => new_email,
 244                                        :display_name => display_name,
 245                                        :auth_provider => "openid",
 246                                        :auth_uid => "http://localhost:1123/new.tester",
 247                                        :pass_crypt => password,
 248                                        :pass_crypt_confirmation => password },
 249                             :read_ct => 1, :read_tou => 1 }
 250           assert_response :redirect
 251           follow_redirect!
 252         end
 253       end
 254     end
 255
 256     # Check the page
 257     assert_response :success
 258     assert_template "confirmations/confirm"
 259
 260     ActionMailer::Base.deliveries.clear
 261   end
 262
 263   def test_user_create_openid_failure
 264     OmniAuth.config.mock_auth[:openid] = :connection_failed
 265
 266     new_email = "newtester-openid2@osm.org"
 267     display_name = "new_tester-openid2"
 268     assert_difference("User.count", 0) do
 269       assert_difference("ActionMailer::Base.deliveries.size", 0) do
 270         perform_enqueued_jobs do
 271           post "/user/new",
 272                :params => { :user => { :email => new_email,
 273                                        :email_confirmation => new_email,
 274                                        :display_name => display_name,
 275                                        :auth_provider => "openid",
 276                                        :auth_uid => "http://localhost:1123/new.tester",
 277                                        :pass_crypt => "",
 278                                        :pass_crypt_confirmation => "" } }
 279           assert_response :redirect
 280           assert_redirected_to auth_path(:provider => "openid", :openid_url => "http://localhost:1123/new.tester", :origin => "/user/new")
 281           post response.location
 282           assert_response :redirect
 283           assert_redirected_to auth_success_path(:provider => "openid", :openid_url => "http://localhost:1123/new.tester", :origin => "/user/new")
 284           follow_redirect!
 285           assert_response :redirect
 286           assert_redirected_to auth_failure_path(:strategy => "openid", :message => "connection_failed", :origin => "/user/new")
 287           follow_redirect!
 288           assert_response :redirect
 289           follow_redirect!
 290           assert_response :success
 291           assert_template "users/new"
 292         end
 293       end
 294     end
 295
 296     ActionMailer::Base.deliveries.clear
 297   end
 298
 299   def test_user_create_openid_redirect
 300     OmniAuth.config.add_mock(:openid, :uid => "http://localhost:1123/new.tester")
 301
 302     new_email = "redirect_tester_openid@osm.org"
 303     display_name = "redirect_tester_openid"
 304     # nothing special about this page, just need a protected page to redirect back to.
 305     referer = "/traces/mine"
 306     assert_difference("User.count") do
 307       assert_difference("ActionMailer::Base.deliveries.size", 1) do
 308         perform_enqueued_jobs do
 309           post "/user/new",
 310                :params => { :user => { :email => new_email,
 311                                        :email_confirmation => new_email,
 312                                        :display_name => display_name,
 313                                        :auth_provider => "openid",
 314                                        :auth_uid => "http://localhost:1123/new.tester",
 315                                        :pass_crypt => "",
 316                                        :pass_crypt_confirmation => "" },
 317                             :referer => referer }
 318           assert_response :redirect
 319           assert_redirected_to auth_path(:provider => "openid", :openid_url => "http://localhost:1123/new.tester", :origin => "/user/new")
 320           post response.location
 321           assert_response :redirect
 322           assert_redirected_to auth_success_path(:provider => "openid", :openid_url => "http://localhost:1123/new.tester", :origin => "/user/new")
 323           follow_redirect!
 324           assert_response :redirect
 325           assert_redirected_to "/user/terms"
 326           post "/user/save",
 327                :params => { :user => { :email => new_email,
 328                                        :email_confirmation => new_email,
 329                                        :display_name => display_name,
 330                                        :auth_provider => "openid",
 331                                        :auth_uid => "http://localhost:1123/new.tester",
 332                                        :pass_crypt => "testtest",
 333                                        :pass_crypt_confirmation => "testtest" },
 334                             :read_ct => 1, :read_tou => 1 }
 335           follow_redirect!
 336         end
 337       end
 338     end
 339
 340     # Check the e-mail
 341     register_email = ActionMailer::Base.deliveries.first
 342
 343     assert_equal register_email.to.first, new_email
 344     # Check that the confirm account url is correct
 345     confirm_regex = Regexp.new("/user/redirect_tester_openid/confirm\\?confirm_string=([a-zA-Z0-9_-]*)")
 346     email_text_parts(register_email).each do |part|
 347       assert_match confirm_regex, part.body.to_s
 348     end
 349     confirm_string = email_text_parts(register_email).first.body.match(confirm_regex)[1]
 350
 351     # Check the page
 352     assert_response :success
 353     assert_template "confirmations/confirm"
 354
 355     ActionMailer::Base.deliveries.clear
 356
 357     # Go to the confirmation page
 358     get "/user/#{display_name}/confirm", :params => { :confirm_string => confirm_string }
 359     assert_response :success
 360     assert_template "confirmations/confirm"
 361
 362     post "/user/#{display_name}/confirm", :params => { :confirm_string => confirm_string }
 363     assert_response :redirect
 364     follow_redirect!
 365     assert_response :success
 366     assert_template "site/welcome"
 367   end
 368
 369   def test_user_create_google_success
 370     new_email = "newtester-google@osm.org"
 371     display_name = "new_tester-google"
 372     password = "testtest"
 373
 374     OmniAuth.config.add_mock(:google, :uid => "123454321", :info => { "email" => new_email })
 375
 376     assert_difference("User.count") do
 377       assert_no_difference("ActionMailer::Base.deliveries.size") do
 378         perform_enqueued_jobs do
 379           post "/user/new",
 380                :params => { :user => { :email => new_email,
 381                                        :email_confirmation => new_email,
 382                                        :display_name => display_name,
 383                                        :auth_provider => "google",
 384                                        :pass_crypt => "",
 385                                        :pass_crypt_confirmation => "" } }
 386           assert_response :redirect
 387           assert_redirected_to auth_path(:provider => "google", :origin => "/user/new")
 388           post response.location
 389           assert_response :redirect
 390           assert_redirected_to auth_success_path(:provider => "google")
 391           follow_redirect!
 392           assert_response :redirect
 393           assert_redirected_to "/user/terms"
 394           post "/user/save",
 395                :params => { :user => { :email => new_email,
 396                                        :email_confirmation => new_email,
 397                                        :display_name => display_name,
 398                                        :auth_provider => "google",
 399                                        :auth_uid => "123454321",
 400                                        :pass_crypt => password,
 401                                        :pass_crypt_confirmation => password },
 402                             :read_ct => 1, :read_tou => 1 }
 403           assert_response :redirect
 404           assert_redirected_to welcome_path
 405           follow_redirect!
 406         end
 407       end
 408     end
 409
 410     # Check the page
 411     assert_response :success
 412     assert_template "site/welcome"
 413
 414     ActionMailer::Base.deliveries.clear
 415   end
 416
 417   def test_user_create_google_failure
 418     OmniAuth.config.mock_auth[:google] = :connection_failed
 419
 420     new_email = "newtester-google2@osm.org"
 421     display_name = "new_tester-google2"
 422     assert_difference("User.count", 0) do
 423       assert_difference("ActionMailer::Base.deliveries.size", 0) do
 424         perform_enqueued_jobs do
 425           post "/user/new",
 426                :params => { :user => { :email => new_email,
 427                                        :email_confirmation => new_email,
 428                                        :display_name => display_name,
 429                                        :auth_provider => "google",
 430                                        :pass_crypt => "",
 431                                        :pass_crypt_confirmation => "" } }
 432           assert_response :redirect
 433           assert_redirected_to auth_path(:provider => "google", :origin => "/user/new")
 434           post response.location
 435           assert_response :redirect
 436           assert_redirected_to auth_success_path(:provider => "google")
 437           follow_redirect!
 438           assert_response :redirect
 439           assert_redirected_to auth_failure_path(:strategy => "google", :message => "connection_failed", :origin => "/user/new")
 440           follow_redirect!
 441           assert_response :redirect
 442           follow_redirect!
 443           assert_response :success
 444           assert_template "users/new"
 445         end
 446       end
 447     end
 448
 449     ActionMailer::Base.deliveries.clear
 450   end
 451
 452   def test_user_create_google_redirect
 453     OmniAuth.config.add_mock(:google, :uid => "123454321", :extra => {
 454                                :id_info => { "openid_id" => "http://localhost:1123/new.tester" }
 455                              })
 456
 457     new_email = "redirect_tester_google@osm.org"
 458     display_name = "redirect_tester_google"
 459     # nothing special about this page, just need a protected page to redirect back to.
 460     referer = "/traces/mine"
 461     assert_difference("User.count") do
 462       assert_difference("ActionMailer::Base.deliveries.size", 1) do
 463         perform_enqueued_jobs do
 464           post "/user/new",
 465                :params => { :user => { :email => new_email,
 466                                        :email_confirmation => new_email,
 467                                        :display_name => display_name,
 468                                        :auth_provider => "google",
 469                                        :pass_crypt => "",
 470                                        :pass_crypt_confirmation => "" },
 471                             :referer => referer }
 472           assert_response :redirect
 473           assert_redirected_to auth_path(:provider => "google", :origin => "/user/new")
 474           post response.location
 475           assert_response :redirect
 476           assert_redirected_to auth_success_path(:provider => "google")
 477           follow_redirect!
 478           assert_response :redirect
 479           assert_redirected_to "/user/terms"
 480           post "/user/save",
 481                :params => { :user => { :email => new_email,
 482                                        :email_confirmation => new_email,
 483                                        :display_name => display_name,
 484                                        :auth_provider => "google",
 485                                        :auth_uid => "http://localhost:1123/new.tester",
 486                                        :pass_crypt => "testtest",
 487                                        :pass_crypt_confirmation => "testtest" },
 488                             :read_ct => 1, :read_tou => 1 }
 489           follow_redirect!
 490         end
 491       end
 492     end
 493
 494     # Check the e-mail
 495     register_email = ActionMailer::Base.deliveries.first
 496
 497     assert_equal register_email.to.first, new_email
 498     # Check that the confirm account url is correct
 499     confirm_regex = Regexp.new("/user/redirect_tester_google/confirm\\?confirm_string=([a-zA-Z0-9_-]*)")
 500     email_text_parts(register_email).each do |part|
 501       assert_match confirm_regex, part.body.to_s
 502     end
 503     confirm_string = email_text_parts(register_email).first.body.match(confirm_regex)[1]
 504
 505     # Check the page
 506     assert_response :success
 507     assert_template "confirmations/confirm"
 508
 509     ActionMailer::Base.deliveries.clear
 510
 511     # Go to the confirmation page
 512     get "/user/#{display_name}/confirm", :params => { :confirm_string => confirm_string }
 513     assert_response :success
 514     assert_template "confirmations/confirm"
 515
 516     post "/user/#{display_name}/confirm", :params => { :confirm_string => confirm_string }
 517     assert_response :redirect
 518     follow_redirect!
 519     assert_response :success
 520     assert_template "site/welcome"
 521   end
 522
 523   def test_user_create_facebook_success
 524     new_email = "newtester-facebook@osm.org"
 525     display_name = "new_tester-facebook"
 526     password = "testtest"
 527
 528     OmniAuth.config.add_mock(:facebook, :uid => "123454321", :info => { "email" => new_email })
 529
 530     assert_difference("User.count") do
 531       assert_no_difference("ActionMailer::Base.deliveries.size") do
 532         perform_enqueued_jobs do
 533           post "/user/new",
 534                :params => { :user => { :email => new_email,
 535                                        :email_confirmation => new_email,
 536                                        :display_name => display_name,
 537                                        :auth_provider => "facebook",
 538                                        :pass_crypt => "",
 539                                        :pass_crypt_confirmation => "" } }
 540           assert_response :redirect
 541           assert_redirected_to auth_path(:provider => "facebook", :origin => "/user/new")
 542           post response.location
 543           assert_response :redirect
 544           assert_redirected_to auth_success_path(:provider => "facebook")
 545           follow_redirect!
 546           assert_response :redirect
 547           assert_redirected_to "/user/terms"
 548           post "/user/save",
 549                :params => { :user => { :email => new_email,
 550                                        :email_confirmation => new_email,
 551                                        :display_name => display_name,
 552                                        :auth_provider => "facebook",
 553                                        :auth_uid => "123454321",
 554                                        :pass_crypt => password,
 555                                        :pass_crypt_confirmation => password },
 556                             :read_ct => 1, :read_tou => 1 }
 557           assert_response :redirect
 558           assert_redirected_to welcome_path
 559           follow_redirect!
 560         end
 561       end
 562     end
 563
 564     # Check the page
 565     assert_response :success
 566     assert_template "site/welcome"
 567
 568     ActionMailer::Base.deliveries.clear
 569   end
 570
 571   def test_user_create_facebook_failure
 572     OmniAuth.config.mock_auth[:facebook] = :connection_failed
 573
 574     new_email = "newtester-facebook2@osm.org"
 575     display_name = "new_tester-facebook2"
 576     assert_difference("User.count", 0) do
 577       assert_difference("ActionMailer::Base.deliveries.size", 0) do
 578         perform_enqueued_jobs do
 579           post "/user/new",
 580                :params => { :user => { :email => new_email,
 581                                        :email_confirmation => new_email,
 582                                        :display_name => display_name,
 583                                        :auth_provider => "facebook",
 584                                        :pass_crypt => "",
 585                                        :pass_crypt_confirmation => "" } }
 586           assert_response :redirect
 587           assert_redirected_to auth_path(:provider => "facebook", :origin => "/user/new")
 588           post response.location
 589           assert_response :redirect
 590           assert_redirected_to auth_success_path(:provider => "facebook")
 591           follow_redirect!
 592           assert_response :redirect
 593           assert_redirected_to auth_failure_path(:strategy => "facebook", :message => "connection_failed", :origin => "/user/new")
 594           follow_redirect!
 595           assert_response :redirect
 596           follow_redirect!
 597           assert_response :success
 598           assert_template "users/new"
 599         end
 600       end
 601     end
 602
 603     ActionMailer::Base.deliveries.clear
 604   end
 605
 606   def test_user_create_facebook_redirect
 607     OmniAuth.config.add_mock(:facebook, :uid => "123454321")
 608
 609     new_email = "redirect_tester_facebook@osm.org"
 610     display_name = "redirect_tester_facebook"
 611     # nothing special about this page, just need a protected page to redirect back to.
 612     referer = "/traces/mine"
 613     assert_difference("User.count") do
 614       assert_difference("ActionMailer::Base.deliveries.size", 1) do
 615         perform_enqueued_jobs do
 616           post "/user/new",
 617                :params => { :user => { :email => new_email,
 618                                        :email_confirmation => new_email,
 619                                        :display_name => display_name,
 620                                        :auth_provider => "facebook",
 621                                        :pass_crypt => "",
 622                                        :pass_crypt_confirmation => "" },
 623                             :referer => referer }
 624           assert_response :redirect
 625           assert_redirected_to auth_path(:provider => "facebook", :origin => "/user/new")
 626           post response.location
 627           assert_response :redirect
 628           assert_redirected_to auth_success_path(:provider => "facebook")
 629           follow_redirect!
 630           assert_response :redirect
 631           assert_redirected_to "/user/terms"
 632           post "/user/save",
 633                :params => { :user => { :email => new_email,
 634                                        :email_confirmation => new_email,
 635                                        :display_name => display_name,
 636                                        :auth_provider => "facebook",
 637                                        :auth_uid => "http://localhost:1123/new.tester",
 638                                        :pass_crypt => "testtest",
 639                                        :pass_crypt_confirmation => "testtest" },
 640                             :read_ct => 1, :read_tou => 1 }
 641           follow_redirect!
 642         end
 643       end
 644     end
 645
 646     # Check the e-mail
 647     register_email = ActionMailer::Base.deliveries.first
 648
 649     assert_equal register_email.to.first, new_email
 650     # Check that the confirm account url is correct
 651     confirm_regex = Regexp.new("/user/redirect_tester_facebook/confirm\\?confirm_string=([a-zA-Z0-9_-]*)")
 652     email_text_parts(register_email).each do |part|
 653       assert_match confirm_regex, part.body.to_s
 654     end
 655     confirm_string = email_text_parts(register_email).first.body.match(confirm_regex)[1]
 656
 657     # Check the page
 658     assert_response :success
 659     assert_template "confirmations/confirm"
 660
 661     ActionMailer::Base.deliveries.clear
 662
 663     # Go to the confirmation page
 664     get "/user/#{display_name}/confirm", :params => { :confirm_string => confirm_string }
 665     assert_response :success
 666     assert_template "confirmations/confirm"
 667
 668     post "/user/#{display_name}/confirm", :params => { :confirm_string => confirm_string }
 669     assert_response :redirect
 670     follow_redirect!
 671     assert_response :success
 672     assert_template "site/welcome"
 673   end
 674
 675   def test_user_create_microsoft_success
 676     new_email = "newtester-microsoft@osm.org"
 677     display_name = "new_tester-microsoft"
 678     password = "testtest"
 679
 680     OmniAuth.config.add_mock(:microsoft, :uid => "123454321", :info => { "email" => new_email })
 681
 682     assert_difference("User.count") do
 683       assert_difference("ActionMailer::Base.deliveries.size", 0) do
 684         perform_enqueued_jobs do
 685           post "/user/new",
 686                :params => { :user => { :email => new_email,
 687                                        :email_confirmation => new_email,
 688                                        :display_name => display_name,
 689                                        :auth_provider => "microsoft",
 690                                        :pass_crypt => "",
 691                                        :pass_crypt_confirmation => "" } }
 692           assert_response :redirect
 693           assert_redirected_to auth_path(:provider => "microsoft", :origin => "/user/new")
 694           post response.location
 695           assert_response :redirect
 696           assert_redirected_to auth_success_path(:provider => "microsoft")
 697           follow_redirect!
 698           assert_response :redirect
 699           assert_redirected_to "/user/terms"
 700           post "/user/save",
 701                :params => { :user => { :email => new_email,
 702                                        :email_confirmation => new_email,
 703                                        :display_name => display_name,
 704                                        :auth_provider => "microsoft",
 705                                        :auth_uid => "123454321",
 706                                        :pass_crypt => password,
 707                                        :pass_crypt_confirmation => password },
 708                             :read_ct => 1, :read_tou => 1 }
 709           assert_response :redirect
 710           assert_redirected_to welcome_path
 711           follow_redirect!
 712         end
 713       end
 714     end
 715
 716     # Check the page
 717     assert_response :success
 718     assert_template "site/welcome"
 719
 720     ActionMailer::Base.deliveries.clear
 721   end
 722
 723   def test_user_create_microsoft_failure
 724     OmniAuth.config.mock_auth[:microsoft] = :connection_failed
 725
 726     new_email = "newtester-microsoft2@osm.org"
 727     display_name = "new_tester-microsoft2"
 728     assert_difference("User.count", 0) do
 729       assert_difference("ActionMailer::Base.deliveries.size", 0) do
 730         perform_enqueued_jobs do
 731           post "/user/new",
 732                :params => { :user => { :email => new_email,
 733                                        :email_confirmation => new_email,
 734                                        :display_name => display_name,
 735                                        :auth_provider => "microsoft",
 736                                        :pass_crypt => "",
 737                                        :pass_crypt_confirmation => "" } }
 738           assert_response :redirect
 739           assert_redirected_to auth_path(:provider => "microsoft", :origin => "/user/new")
 740           post response.location
 741           assert_response :redirect
 742           assert_redirected_to auth_success_path(:provider => "microsoft")
 743           follow_redirect!
 744           assert_response :redirect
 745           assert_redirected_to auth_failure_path(:strategy => "microsoft", :message => "connection_failed", :origin => "/user/new")
 746           follow_redirect!
 747           assert_response :redirect
 748           follow_redirect!
 749           assert_response :success
 750           assert_template "users/new"
 751         end
 752       end
 753     end
 754
 755     ActionMailer::Base.deliveries.clear
 756   end
 757
 758   def test_user_create_microsoft_redirect
 759     OmniAuth.config.add_mock(:microsoft, :uid => "123454321")
 760
 761     new_email = "redirect_tester_microsoft@osm.org"
 762     display_name = "redirect_tester_microsoft"
 763     # nothing special about this page, just need a protected page to redirect back to.
 764     referer = "/traces/mine"
 765     assert_difference("User.count") do
 766       assert_difference("ActionMailer::Base.deliveries.size", 1) do
 767         perform_enqueued_jobs do
 768           post "/user/new",
 769                :params => { :user => { :email => new_email,
 770                                        :email_confirmation => new_email,
 771                                        :display_name => display_name,
 772                                        :auth_provider => "microsoft",
 773                                        :pass_crypt => "",
 774                                        :pass_crypt_confirmation => "" },
 775                             :referer => referer }
 776           assert_response :redirect
 777           assert_redirected_to auth_path(:provider => "microsoft", :origin => "/user/new")
 778           post response.location
 779           assert_response :redirect
 780           assert_redirected_to auth_success_path(:provider => "microsoft")
 781           follow_redirect!
 782           assert_response :redirect
 783           assert_redirected_to "/user/terms"
 784           post "/user/save",
 785                :params => { :user => { :email => new_email,
 786                                        :email_confirmation => new_email,
 787                                        :display_name => display_name,
 788                                        :auth_provider => "microsoft",
 789                                        :auth_uid => "http://localhost:1123/new.tester",
 790                                        :pass_crypt => "testtest",
 791                                        :pass_crypt_confirmation => "testtest" },
 792                             :read_ct => 1, :read_tou => 1 }
 793           follow_redirect!
 794         end
 795       end
 796     end
 797
 798     # Check the e-mail
 799     register_email = ActionMailer::Base.deliveries.first
 800
 801     assert_equal register_email.to.first, new_email
 802     # Check that the confirm account url is correct
 803     confirm_regex = Regexp.new("/user/redirect_tester_microsoft/confirm\\?confirm_string=([a-zA-Z0-9_-]*)")
 804     email_text_parts(register_email).each do |part|
 805       assert_match confirm_regex, part.body.to_s
 806     end
 807     confirm_string = email_text_parts(register_email).first.body.match(confirm_regex)[1]
 808
 809     # Check the page
 810     assert_response :success
 811     assert_template "confirmations/confirm"
 812
 813     ActionMailer::Base.deliveries.clear
 814
 815     # Go to the confirmation page
 816     get "/user/#{display_name}/confirm", :params => { :confirm_string => confirm_string }
 817     assert_response :success
 818     assert_template "confirmations/confirm"
 819
 820     post "/user/#{display_name}/confirm", :params => { :confirm_string => confirm_string }
 821     assert_response :redirect
 822     follow_redirect!
 823     assert_response :success
 824     assert_template "site/welcome"
 825   end
 826
 827   def test_user_create_github_success
 828     new_email = "newtester-github@osm.org"
 829     display_name = "new_tester-github"
 830     password = "testtest"
 831
 832     OmniAuth.config.add_mock(:github, :uid => "123454321", :info => { "email" => new_email })
 833
 834     assert_difference("User.count") do
 835       assert_difference("ActionMailer::Base.deliveries.size", 1) do
 836         perform_enqueued_jobs do
 837           post "/user/new",
 838                :params => { :user => { :email => new_email,
 839                                        :email_confirmation => new_email,
 840                                        :display_name => display_name,
 841                                        :auth_provider => "github",
 842                                        :pass_crypt => "",
 843                                        :pass_crypt_confirmation => "" } }
 844           assert_response :redirect
 845           assert_redirected_to auth_path(:provider => "github", :origin => "/user/new")
 846           post response.location
 847           assert_response :redirect
 848           assert_redirected_to auth_success_path(:provider => "github")
 849           follow_redirect!
 850           assert_response :redirect
 851           assert_redirected_to "/user/terms"
 852           post "/user/save",
 853                :params => { :user => { :email => new_email,
 854                                        :email_confirmation => new_email,
 855                                        :display_name => display_name,
 856                                        :auth_provider => "github",
 857                                        :auth_uid => "123454321",
 858                                        :pass_crypt => password,
 859                                        :pass_crypt_confirmation => password },
 860                             :read_ct => 1,
 861                             :read_tou => 1 }
 862           assert_response :redirect
 863           assert_redirected_to :controller => :confirmations, :action => :confirm, :display_name => display_name
 864           follow_redirect!
 865         end
 866       end
 867     end
 868
 869     # Check the page
 870     assert_response :success
 871     assert_template "confirmations/confirm"
 872
 873     ActionMailer::Base.deliveries.clear
 874   end
 875
 876   def test_user_create_github_failure
 877     OmniAuth.config.mock_auth[:github] = :connection_failed
 878
 879     new_email = "newtester-github2@osm.org"
 880     display_name = "new_tester-github2"
 881     assert_difference("User.count", 0) do
 882       assert_difference("ActionMailer::Base.deliveries.size", 0) do
 883         perform_enqueued_jobs do
 884           post "/user/new",
 885                :params => { :user => { :email => new_email,
 886                                        :email_confirmation => new_email,
 887                                        :display_name => display_name,
 888                                        :auth_provider => "github",
 889                                        :pass_crypt => "",
 890                                        :pass_crypt_confirmation => "" } }
 891           assert_response :redirect
 892           assert_redirected_to auth_path(:provider => "github", :origin => "/user/new")
 893           post response.location
 894           assert_response :redirect
 895           assert_redirected_to auth_success_path(:provider => "github")
 896           follow_redirect!
 897           assert_response :redirect
 898           assert_redirected_to auth_failure_path(:strategy => "github", :message => "connection_failed", :origin => "/user/new")
 899           follow_redirect!
 900           assert_response :redirect
 901           follow_redirect!
 902           assert_response :success
 903           assert_template "users/new"
 904         end
 905       end
 906     end
 907
 908     ActionMailer::Base.deliveries.clear
 909   end
 910
 911   def test_user_create_github_redirect
 912     OmniAuth.config.add_mock(:github, :uid => "123454321")
 913
 914     new_email = "redirect_tester_github@osm.org"
 915     display_name = "redirect_tester_github"
 916     # nothing special about this page, just need a protected page to redirect back to.
 917     referer = "/traces/mine"
 918     assert_difference("User.count") do
 919       assert_difference("ActionMailer::Base.deliveries.size", 1) do
 920         perform_enqueued_jobs do
 921           post "/user/new",
 922                :params => { :user => { :email => new_email,
 923                                        :email_confirmation => new_email,
 924                                        :display_name => display_name,
 925                                        :auth_provider => "github",
 926                                        :pass_crypt => "",
 927                                        :pass_crypt_confirmation => "" },
 928                             :referer => referer }
 929           assert_response :redirect
 930           assert_redirected_to auth_path(:provider => "github", :origin => "/user/new")
 931           post response.location
 932           assert_response :redirect
 933           assert_redirected_to auth_success_path(:provider => "github")
 934           follow_redirect!
 935           assert_response :redirect
 936           assert_redirected_to "/user/terms"
 937           post "/user/save",
 938                :params => { :user => { :email => new_email,
 939                                        :email_confirmation => new_email,
 940                                        :display_name => display_name,
 941                                        :auth_provider => "github",
 942                                        :auth_uid => "http://localhost:1123/new.tester",
 943                                        :pass_crypt => "testtest",
 944                                        :pass_crypt_confirmation => "testtest" },
 945                             :read_ct => 1,
 946                             :read_tou => 1 }
 947           follow_redirect!
 948         end
 949       end
 950     end
 951
 952     # Check the e-mail
 953     register_email = ActionMailer::Base.deliveries.first
 954
 955     assert_equal register_email.to.first, new_email
 956     # Check that the confirm account url is correct
 957     confirm_regex = Regexp.new("/user/redirect_tester_github/confirm\\?confirm_string=([a-zA-Z0-9_-]*)")
 958     email_text_parts(register_email).each do |part|
 959       assert_match confirm_regex, part.body.to_s
 960     end
 961     confirm_string = email_text_parts(register_email).first.body.match(confirm_regex)[1]
 962
 963     # Check the page
 964     assert_response :success
 965     assert_template "confirmations/confirm"
 966
 967     ActionMailer::Base.deliveries.clear
 968
 969     # Go to the confirmation page
 970     get "/user/#{display_name}/confirm", :params => { :confirm_string => confirm_string }
 971     assert_response :success
 972     assert_template "confirmations/confirm"
 973
 974     post "/user/#{display_name}/confirm", :params => { :confirm_string => confirm_string }
 975     assert_response :redirect
 976     follow_redirect!
 977     assert_response :success
 978     assert_template "site/welcome"
 979   end
 980
 981   def test_user_create_wikipedia_success
 982     new_email = "newtester-wikipedia@osm.org"
 983     display_name = "new_tester-wikipedia"
 984     password = "testtest"
 985
 986     OmniAuth.config.add_mock(:wikipedia, :uid => "123454321", :info => { "email" => new_email })
 987
 988     assert_difference("User.count") do
 989       assert_difference("ActionMailer::Base.deliveries.size", 1) do
 990         perform_enqueued_jobs do
 991           post "/user/new",
 992                :params => { :user => { :email => new_email,
 993                                        :email_confirmation => new_email,
 994                                        :display_name => display_name,
 995                                        :auth_provider => "wikipedia",
 996                                        :pass_crypt => "",
 997                                        :pass_crypt_confirmation => "" } }
 998           assert_response :redirect
 999           assert_redirected_to auth_path(:provider => "wikipedia", :origin => "/user/new")
1000           post response.location
1001           assert_response :redirect
1002           assert_redirected_to auth_success_path(:provider => "wikipedia", :origin => "/user/new")
1003           follow_redirect!
1004           assert_response :redirect
1005           assert_redirected_to "/user/terms"
1006           post "/user/save",
1007                :params => { :user => { :email => new_email,
1008                                        :email_confirmation => new_email,
1009                                        :display_name => display_name,
1010                                        :auth_provider => "wikipedia",
1011                                        :auth_uid => "123454321",
1012                                        :pass_crypt => password,
1013                                        :pass_crypt_confirmation => password },
1014                             :read_ct => 1,
1015                             :read_tou => 1 }
1016           assert_response :redirect
1017           assert_redirected_to :controller => :confirmations, :action => :confirm, :display_name => display_name
1018           follow_redirect!
1019         end
1020       end
1021     end
1022
1023     # Check the page
1024     assert_response :success
1025     assert_template "confirmations/confirm"
1026
1027     ActionMailer::Base.deliveries.clear
1028   end
1029
1030   def test_user_create_wikipedia_failure
1031     OmniAuth.config.mock_auth[:wikipedia] = :connection_failed
1032
1033     new_email = "newtester-wikipedia2@osm.org"
1034     display_name = "new_tester-wikipedia2"
1035     assert_difference("User.count", 0) do
1036       assert_difference("ActionMailer::Base.deliveries.size", 0) do
1037         perform_enqueued_jobs do
1038           post "/user/new",
1039                :params => { :user => { :email => new_email,
1040                                        :email_confirmation => new_email,
1041                                        :display_name => display_name,
1042                                        :auth_provider => "wikipedia",
1043                                        :pass_crypt => "",
1044                                        :pass_crypt_confirmation => "" } }
1045           assert_response :redirect
1046           assert_redirected_to auth_path(:provider => "wikipedia", :origin => "/user/new")
1047           post response.location
1048           assert_response :redirect
1049           assert_redirected_to auth_success_path(:provider => "wikipedia", :origin => "/user/new")
1050           follow_redirect!
1051           assert_response :redirect
1052           assert_redirected_to auth_failure_path(:strategy => "wikipedia", :message => "connection_failed", :origin => "/user/new")
1053           follow_redirect!
1054           assert_response :redirect
1055           follow_redirect!
1056           assert_response :success
1057           assert_template "users/new"
1058         end
1059       end
1060     end
1061
1062     ActionMailer::Base.deliveries.clear
1063   end
1064
1065   def test_user_create_wikipedia_redirect
1066     OmniAuth.config.add_mock(:wikipedia, :uid => "123454321")
1067
1068     new_email = "redirect_tester_wikipedia@osm.org"
1069     display_name = "redirect_tester_wikipedia"
1070     # nothing special about this page, just need a protected page to redirect back to.
1071     referer = "/traces/mine"
1072     assert_difference("User.count") do
1073       assert_difference("ActionMailer::Base.deliveries.size", 1) do
1074         perform_enqueued_jobs do
1075           post "/user/new",
1076                :params => { :user => { :email => new_email,
1077                                        :email_confirmation => new_email,
1078                                        :display_name => display_name,
1079                                        :auth_provider => "wikipedia",
1080                                        :pass_crypt => "",
1081                                        :pass_crypt_confirmation => "" },
1082                             :referer => referer }
1083           assert_response :redirect
1084           assert_redirected_to auth_path(:provider => "wikipedia", :origin => "/user/new")
1085           post response.location
1086           assert_response :redirect
1087           assert_redirected_to auth_success_path(:provider => "wikipedia", :origin => "/user/new")
1088           follow_redirect!
1089           assert_response :redirect
1090           assert_redirected_to "/user/terms"
1091           post "/user/save",
1092                :params => { :user => { :email => new_email,
1093                                        :email_confirmation => new_email,
1094                                        :display_name => display_name,
1095                                        :auth_provider => "wikipedia",
1096                                        :auth_uid => "http://localhost:1123/new.tester",
1097                                        :pass_crypt => "testtest",
1098                                        :pass_crypt_confirmation => "testtest" },
1099                             :read_ct => 1,
1100                             :read_tou => 1 }
1101           follow_redirect!
1102         end
1103       end
1104     end
1105
1106     # Check the e-mail
1107     register_email = ActionMailer::Base.deliveries.first
1108
1109     assert_equal register_email.to.first, new_email
1110     # Check that the confirm account url is correct
1111     confirm_regex = Regexp.new("/user/redirect_tester_wikipedia/confirm\\?confirm_string=([a-zA-Z0-9_-]*)")
1112     email_text_parts(register_email).each do |part|
1113       assert_match confirm_regex, part.body.to_s
1114     end
1115     confirm_string = email_text_parts(register_email).first.body.match(confirm_regex)[1]
1116
1117     # Check the page
1118     assert_response :success
1119     assert_template "confirmations/confirm"
1120
1121     ActionMailer::Base.deliveries.clear
1122
1123     # Go to the confirmation page
1124     get "/user/#{display_name}/confirm", :params => { :confirm_string => confirm_string }
1125     assert_response :success
1126     assert_template "confirmations/confirm"
1127
1128     post "/user/#{display_name}/confirm", :params => { :confirm_string => confirm_string }
1129     assert_response :redirect
1130     follow_redirect!
1131     assert_response :success
1132     assert_template "site/welcome"
1133   end
1134 end