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