devise 3.2.1 → 4.4.3

data/test/generators/controllers_generator_test.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "test_helper"
+
+class ControllersGeneratorTest < Rails::Generators::TestCase
+  tests Devise::Generators::ControllersGenerator
+  destination File.expand_path("../../tmp", __FILE__)
+  setup :prepare_destination
+
+  test "Assert no controllers are created with no params" do
+    capture(:stderr) { run_generator }
+    assert_no_file "app/controllers/sessions_controller.rb"
+    assert_no_file "app/controllers/registrations_controller.rb"
+    assert_no_file "app/controllers/confirmations_controller.rb"
+    assert_no_file "app/controllers/passwords_controller.rb"
+    assert_no_file "app/controllers/unlocks_controller.rb"
+    assert_no_file "app/controllers/omniauth_callbacks_controller.rb"
+  end
+
+  test "Assert all controllers are properly created with scope param" do
+    run_generator %w(users)
+    assert_class_names 'users'
+
+    run_generator %w(admins)
+    assert_class_names 'admins'
+  end
+
+  test "Assert specified controllers with scope" do
+    run_generator %w(users -c sessions)
+    assert_file "app/controllers/users/sessions_controller.rb"
+    assert_no_file "app/controllers/users/registrations_controller.rb"
+    assert_no_file "app/controllers/users/confirmations_controller.rb"
+    assert_no_file "app/controllers/users/passwords_controller.rb"
+    assert_no_file "app/controllers/users/unlocks_controller.rb"
+    assert_no_file "app/controllers/users/omniauth_callbacks_controller.rb"
+  end
+
+  private
+
+    def assert_class_names(scope, options = {})
+      base_dir = "app/controllers#{scope.blank? ? '' : ('/' + scope)}"
+      scope_prefix = scope.blank? ? '' : (scope.camelize + '::')
+      controllers = options[:controllers] ||
+        %w(confirmations passwords registrations sessions unlocks omniauth_callbacks)
+
+      controllers.each do |c|
+        assert_file "#{base_dir}/#{c}_controller.rb", /#{scope_prefix + c.camelize}/
+      end
+    end
+end

data/test/generators/devise_generator_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
 require "generators/devise/devise_generator"
@@ -18,13 +20,13 @@ class DeviseGeneratorTest < Rails::Generators::TestCase
 
   test "route generation for namespaced model names" do
     run_generator %w(monster/goblin name:string)
-    match = /devise_for :goblins, :class_name => "Monster::Goblin"/
+    match = /devise_for :goblins, class_name: "Monster::Goblin"/
     assert_file "config/routes.rb", match
   end
 
   test "route generation with skip routes" do
     run_generator %w(monster name:string --skip-routes)
-    match = /devise_for :monsters, :skip => :all/
+    match = /devise_for :monsters, skip: :all/
     assert_file "config/routes.rb", match
   end
 

data/test/generators/install_generator_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "test_helper"
 
 class InstallGeneratorTest < Rails::Generators::TestCase
@@ -5,9 +7,20 @@ class InstallGeneratorTest < Rails::Generators::TestCase
   destination File.expand_path("../../tmp", __FILE__)
   setup :prepare_destination
 
-  test "Assert all files are properly created" do
-    run_generator
-    assert_file "config/initializers/devise.rb"
+  test "assert all files are properly created" do
+    run_generator(["--orm=active_record"])
+    assert_file "config/initializers/devise.rb", /devise\/orm\/active_record/
     assert_file "config/locales/devise.en.yml"
   end
+
+  test "fails if no ORM is specified" do
+    stderr = capture(:stderr) do
+      run_generator
+    end
+
+    assert_match %r{An ORM must be set to install Devise}, stderr
+
+    assert_no_file "config/initializers/devise.rb"
+    assert_no_file "config/locales/devise.en.yml"
+  end
 end

data/test/generators/mongoid_generator_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "test_helper"
 
 if DEVISE_ORM == :mongoid
@@ -7,15 +9,15 @@ if DEVISE_ORM == :mongoid
     tests Mongoid::Generators::DeviseGenerator
     destination File.expand_path("../../tmp", __FILE__)
     setup :prepare_destination
-  
+
     test "all files are properly created" do
       run_generator %w(monster)
       assert_file "app/models/monster.rb", /devise/
     end
-  
+
     test "all files are properly deleted" do
       run_generator %w(monster)
-      run_generator %w(monster), :behavior => :revoke
+      run_generator %w(monster), behavior: :revoke
       assert_no_file "app/models/monster.rb"
     end
   end

data/test/generators/views_generator_test.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "test_helper"
 
 class ViewsGeneratorTest < Rails::Generators::TestCase
@@ -33,7 +35,43 @@ class ViewsGeneratorTest < Rails::Generators::TestCase
 
   test "Assert views with markerb" do
     run_generator %w(--markerb)
-    assert_files nil, :mail_template_engine => "markerb"
+    assert_files nil, mail_template_engine: "markerb"
+  end
+
+
+  test "Assert only views within specified directories" do
+    run_generator %w(-v sessions registrations)
+    assert_file "app/views/devise/sessions/new.html.erb"
+    assert_file "app/views/devise/registrations/new.html.erb"
+    assert_file "app/views/devise/registrations/edit.html.erb"
+    assert_no_file "app/views/devise/confirmations/new.html.erb"
+    assert_no_file "app/views/devise/mailer/confirmation_instructions.html.erb"
+  end
+
+  test "Assert mailer specific directory with simple form" do
+    run_generator %w(-v mailer -b simple_form_for)
+    assert_file "app/views/devise/mailer/confirmation_instructions.html.erb"
+    assert_file "app/views/devise/mailer/reset_password_instructions.html.erb"
+    assert_file "app/views/devise/mailer/unlock_instructions.html.erb"
+  end
+
+  test "Assert specified directories with scope" do
+    run_generator %w(users -v sessions)
+    assert_file "app/views/users/sessions/new.html.erb"
+    assert_no_file "app/views/users/confirmations/new.html.erb"
+  end
+
+  test "Assert specified directories with simple form" do
+    run_generator %w(-v registrations -b simple_form_for)
+    assert_file "app/views/devise/registrations/new.html.erb", /simple_form_for/
+    assert_no_file "app/views/devise/confirmations/new.html.erb"
+    end
+
+  test "Assert specified directories with markerb" do
+    run_generator %w(--markerb -v passwords mailer)
+    assert_file "app/views/devise/passwords/new.html.erb"
+    assert_no_file "app/views/devise/confirmations/new.html.erb"
+    assert_file "app/views/devise/mailer/reset_password_instructions.markerb"
   end
 
   def assert_files(scope = nil, options={})
@@ -49,7 +87,7 @@ class ViewsGeneratorTest < Rails::Generators::TestCase
     assert_file "app/views/#{scope}/registrations/new.html.erb"
     assert_file "app/views/#{scope}/registrations/edit.html.erb"
     assert_file "app/views/#{scope}/sessions/new.html.erb"
-    assert_file "app/views/#{scope}/shared/_links.erb"
+    assert_file "app/views/#{scope}/shared/_links.html.erb"
     assert_file "app/views/#{scope}/unlocks/new.html.erb"
   end
 

data/test/helpers/devise_helper_test.rb

@@ -1,35 +1,36 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
-class DeviseHelperTest < ActionDispatch::IntegrationTest
+class DeviseHelperTest < Devise::IntegrationTest
   setup do
-    model_labels = { :models => { :user => "utilisateur" } }
-
-    I18n.backend.store_translations :fr,
-    {
-      :errors => { :messages => { :not_saved => {
-        :one => "Erreur lors de l'enregistrement de '%{resource}': 1 erreur.",
-        :other => "Erreur lors de l'enregistrement de '%{resource}': %{count} erreurs."
+    model_labels = { models: { user: "the user" } }
+    translations = {
+      errors: { messages: { not_saved: {
+        one: "Can't save %{resource} because of 1 error",
+        other: "Can't save %{resource} because of %{count} errors",
       } } },
-      :activerecord => model_labels,
-      :mongoid => model_labels
+      activerecord: model_labels,
+      mongoid: model_labels
     }
 
-    I18n.locale = 'fr'
+    I18n.available_locales
+    I18n.backend.store_translations(:en, translations)
   end
 
   teardown do
-    I18n.locale = 'en'
+    I18n.reload!
   end
 
   test 'test errors.messages.not_saved with single error from i18n' do
     get new_user_registration_path
 
-    fill_in 'password', :with => 'new_user123'
-    fill_in 'password confirmation', :with => 'new_user123'
+    fill_in 'password', with: 'new_user123'
+    fill_in 'password confirmation', with: 'new_user123'
     click_button 'Sign up'
 
     assert_have_selector '#error_explanation'
-    assert_contain "Erreur lors de l'enregistrement de 'utilisateur': 1 erreur"
+    assert_contain "Can't save the user because of 1 error"
   end
 
   test 'test errors.messages.not_saved with multiple errors from i18n' do
@@ -39,13 +40,12 @@ class DeviseHelperTest < ActionDispatch::IntegrationTest
 
     get new_user_registration_path
 
-    fill_in 'email', :with => 'invalid_email'
-    fill_in 'password', :with => 'new_user123'
-    fill_in 'password confirmation', :with => 'new_user321'
+    fill_in 'email', with: 'invalid_email'
+    fill_in 'password', with: 'new_user123'
+    fill_in 'password confirmation', with: 'new_user321'
     click_button 'Sign up'
 
     assert_have_selector '#error_explanation'
-    assert_contain "Erreur lors de l'enregistrement de 'utilisateur': 2 erreurs"
+    assert_contain "Can't save the user because of 2 errors"
   end
 end
-

data/test/integration/authenticatable_test.rb

@@ -1,6 +1,14 @@
+# frozen_string_literal: true
+
 require 'test_helper'
 
-class AuthenticationSanityTest < ActionDispatch::IntegrationTest
+class AuthenticationSanityTest < Devise::IntegrationTest
+  test 'sign in should not run model validations' do
+    sign_in_as_user
+
+    refute User.validations_performed
+  end
+
   test 'home should be accessible without sign in' do
     visit '/'
     assert_response :success
@@ -10,13 +18,13 @@ class AuthenticationSanityTest < ActionDispatch::IntegrationTest
   test 'sign in as user should not authenticate admin scope' do
     sign_in_as_user
     assert warden.authenticated?(:user)
-    assert_not warden.authenticated?(:admin)
+    refute warden.authenticated?(:admin)
   end
 
   test 'sign in as admin should not authenticate user scope' do
     sign_in_as_admin
     assert warden.authenticated?(:admin)
-    assert_not warden.authenticated?(:user)
+    refute warden.authenticated?(:user)
   end
 
   test 'sign in as both user and admin at same time' do
@@ -27,58 +35,58 @@ class AuthenticationSanityTest < ActionDispatch::IntegrationTest
   end
 
   test 'sign out as user should not touch admin authentication if sign_out_all_scopes is false' do
-    swap Devise, :sign_out_all_scopes => false do
+    swap Devise, sign_out_all_scopes: false do
       sign_in_as_user
       sign_in_as_admin
-      get destroy_user_session_path
-      assert_not warden.authenticated?(:user)
+      delete destroy_user_session_path
+      refute warden.authenticated?(:user)
       assert warden.authenticated?(:admin)
     end
   end
 
   test 'sign out as admin should not touch user authentication if sign_out_all_scopes is false' do
-    swap Devise, :sign_out_all_scopes => false do
+    swap Devise, sign_out_all_scopes: false do
       sign_in_as_user
       sign_in_as_admin
 
-      get destroy_admin_session_path
-      assert_not warden.authenticated?(:admin)
+      delete destroy_admin_session_path
+      refute warden.authenticated?(:admin)
       assert warden.authenticated?(:user)
     end
   end
 
   test 'sign out as user should also sign out admin if sign_out_all_scopes is true' do
-    swap Devise, :sign_out_all_scopes => true do
+    swap Devise, sign_out_all_scopes: true do
       sign_in_as_user
       sign_in_as_admin
 
-      get destroy_user_session_path
-      assert_not warden.authenticated?(:user)
-      assert_not warden.authenticated?(:admin)
+      delete destroy_user_session_path
+      refute warden.authenticated?(:user)
+      refute warden.authenticated?(:admin)
     end
   end
 
   test 'sign out as admin should also sign out user if sign_out_all_scopes is true' do
-    swap Devise, :sign_out_all_scopes => true do
+    swap Devise, sign_out_all_scopes: true do
       sign_in_as_user
       sign_in_as_admin
 
-      get destroy_admin_session_path
-      assert_not warden.authenticated?(:admin)
-      assert_not warden.authenticated?(:user)
+      delete destroy_admin_session_path
+      refute warden.authenticated?(:admin)
+      refute warden.authenticated?(:user)
     end
   end
 
   test 'not signed in as admin should not be able to access admins actions' do
     get admins_path
     assert_redirected_to new_admin_session_path
-    assert_not warden.authenticated?(:admin)
+    refute warden.authenticated?(:admin)
   end
 
   test 'signed in as user should not be able to access admins actions' do
     sign_in_as_user
     assert warden.authenticated?(:user)
-    assert_not warden.authenticated?(:admin)
+    refute warden.authenticated?(:admin)
 
     get admins_path
     assert_redirected_to new_admin_session_path
@@ -87,7 +95,7 @@ class AuthenticationSanityTest < ActionDispatch::IntegrationTest
   test 'signed in as admin should be able to access admin actions' do
     sign_in_as_admin
     assert warden.authenticated?(:admin)
-    assert_not warden.authenticated?(:user)
+    refute warden.authenticated?(:user)
 
     get admins_path
 
@@ -109,22 +117,22 @@ class AuthenticationSanityTest < ActionDispatch::IntegrationTest
     sign_in_as_admin
     assert warden.authenticated?(:admin)
 
-    get destroy_admin_session_path
+    delete destroy_admin_session_path
     assert_response :redirect
     assert_redirected_to root_path
 
     get root_path
     assert_contain 'Signed out successfully'
-    assert_not warden.authenticated?(:admin)
+    refute warden.authenticated?(:admin)
   end
 
-  test 'unauthenticated admin does not set message on sign out' do
-    get destroy_admin_session_path
+  test 'unauthenticated admin set message on sign out' do
+    delete destroy_admin_session_path
     assert_response :redirect
     assert_redirected_to root_path
 
     get root_path
-    assert_not_contain 'Signed out successfully'
+    assert_contain 'Signed out successfully'
   end
 
   test 'scope uses custom failure app' do
@@ -134,17 +142,17 @@ class AuthenticationSanityTest < ActionDispatch::IntegrationTest
   end
 end
 
-class AuthenticationRoutesRestrictions < ActionDispatch::IntegrationTest
+class AuthenticationRoutesRestrictions < Devise::IntegrationTest
   test 'not signed in should not be able to access private route (authenticate denied)' do
     get private_path
     assert_redirected_to new_admin_session_path
-    assert_not warden.authenticated?(:admin)
+    refute warden.authenticated?(:admin)
   end
 
   test 'signed in as user should not be able to access private route restricted to admins (authenticate denied)' do
     sign_in_as_user
     assert warden.authenticated?(:user)
-    assert_not warden.authenticated?(:admin)
+    refute warden.authenticated?(:admin)
     get private_path
     assert_redirected_to new_admin_session_path
   end
@@ -152,7 +160,7 @@ class AuthenticationRoutesRestrictions < ActionDispatch::IntegrationTest
   test 'signed in as admin should be able to access private route restricted to admins (authenticate accepted)' do
     sign_in_as_admin
     assert warden.authenticated?(:admin)
-    assert_not warden.authenticated?(:user)
+    refute warden.authenticated?(:user)
 
     get private_path
 
@@ -162,9 +170,9 @@ class AuthenticationRoutesRestrictions < ActionDispatch::IntegrationTest
   end
 
   test 'signed in as inactive admin should not be able to access private/active route restricted to active admins (authenticate denied)' do
-    sign_in_as_admin(:active => false)
+    sign_in_as_admin(active: false)
     assert warden.authenticated?(:admin)
-    assert_not warden.authenticated?(:user)
+    refute warden.authenticated?(:user)
 
     assert_raises ActionController::RoutingError do
       get "/private/active"
@@ -172,9 +180,9 @@ class AuthenticationRoutesRestrictions < ActionDispatch::IntegrationTest
   end
 
   test 'signed in as active admin should be able to access private/active route restricted to active admins (authenticate accepted)' do
-    sign_in_as_admin(:active => true)
+    sign_in_as_admin(active: true)
     assert warden.authenticated?(:admin)
-    assert_not warden.authenticated?(:user)
+    refute warden.authenticated?(:user)
 
     get private_active_path
 
@@ -186,7 +194,7 @@ class AuthenticationRoutesRestrictions < ActionDispatch::IntegrationTest
   test 'signed in as admin should get admin dashboard (authenticated accepted)' do
     sign_in_as_admin
     assert warden.authenticated?(:admin)
-    assert_not warden.authenticated?(:user)
+    refute warden.authenticated?(:user)
 
     get dashboard_path
 
@@ -198,7 +206,7 @@ class AuthenticationRoutesRestrictions < ActionDispatch::IntegrationTest
   test 'signed in as user should get user dashboard (authenticated accepted)' do
     sign_in_as_user
     assert warden.authenticated?(:user)
-    assert_not warden.authenticated?(:admin)
+    refute warden.authenticated?(:admin)
 
     get dashboard_path
 
@@ -214,9 +222,9 @@ class AuthenticationRoutesRestrictions < ActionDispatch::IntegrationTest
   end
 
   test 'signed in as inactive admin should not be able to access dashboard/active route restricted to active admins (authenticated denied)' do
-    sign_in_as_admin(:active => false)
+    sign_in_as_admin(active: false)
     assert warden.authenticated?(:admin)
-    assert_not warden.authenticated?(:user)
+    refute warden.authenticated?(:user)
 
     assert_raises ActionController::RoutingError do
       get "/dashboard/active"
@@ -224,9 +232,9 @@ class AuthenticationRoutesRestrictions < ActionDispatch::IntegrationTest
   end
 
   test 'signed in as active admin should be able to access dashboard/active route restricted to active admins (authenticated accepted)' do
-    sign_in_as_admin(:active => true)
+    sign_in_as_admin(active: true)
     assert warden.authenticated?(:admin)
-    assert_not warden.authenticated?(:user)
+    refute warden.authenticated?(:user)
 
     get dashboard_active_path
 
@@ -238,14 +246,14 @@ class AuthenticationRoutesRestrictions < ActionDispatch::IntegrationTest
   test 'signed in user should not see unauthenticated page (unauthenticated denied)' do
     sign_in_as_user
     assert warden.authenticated?(:user)
-    assert_not warden.authenticated?(:admin)
+    refute warden.authenticated?(:admin)
 
     assert_raises ActionController::RoutingError do
       get join_path
     end
   end
 
-  test 'not signed in users should see unautheticated page (unauthenticated accepted)' do
+  test 'not signed in users should see unauthenticated page (unauthenticated accepted)' do
     get join_path
 
     assert_response :success
@@ -254,7 +262,7 @@ class AuthenticationRoutesRestrictions < ActionDispatch::IntegrationTest
   end
 end
 
-class AuthenticationRedirectTest < ActionDispatch::IntegrationTest
+class AuthenticationRedirectTest < Devise::IntegrationTest
   test 'redirect from warden shows sign in or sign up message' do
     get admins_path
 
@@ -277,7 +285,7 @@ class AuthenticationRedirectTest < ActionDispatch::IntegrationTest
     assert_equal users_path, session[:"user_return_to"]
 
     follow_redirect!
-    sign_in_as_user :visit => false
+    sign_in_as_user visit: false
 
     assert_current_url '/users'
     assert_nil session[:"user_return_to"]
@@ -293,14 +301,14 @@ class AuthenticationRedirectTest < ActionDispatch::IntegrationTest
     assert_equal users_path, session[:"user_return_to"]
 
     follow_redirect!
-    sign_in_as_user :visit => false
+    sign_in_as_user visit: false
 
     assert_current_url '/users'
     assert_nil session[:"user_return_to"]
   end
 
   test 'xml http requests does not store urls for redirect' do
-    get users_path, {}, 'HTTP_X_REQUESTED_WITH' => 'XMLHttpRequest'
+    get users_path, headers: { 'HTTP_X_REQUESTED_WITH' => 'XMLHttpRequest' }
     assert_equal 401, response.status
     assert_nil session[:"user_return_to"]
   end
@@ -317,7 +325,7 @@ class AuthenticationRedirectTest < ActionDispatch::IntegrationTest
   end
 end
 
-class AuthenticationSessionTest < ActionDispatch::IntegrationTest
+class AuthenticationSessionTest < Devise::IntegrationTest
   test 'destroyed account is signed out' do
     sign_in_as_user
     get '/users'
@@ -347,37 +355,6 @@ class AuthenticationSessionTest < ActionDispatch::IntegrationTest
     assert_equal "Cart", @controller.user_session[:cart]
   end
 
-  test 'does not explode when class name is still stored in session' do
-    # In order to test that old sessions do not break with the new scoped
-    # deserialization, we need to serialize the session the old way. This is
-    # done by removing the newly used scoped serialization method
-    # (#user_serialize) and bringing back the old uncsoped #serialize method
-    # that includes the record's class name in the serialization.
-    begin
-      Warden::SessionSerializer.class_eval do
-        alias_method :original_serialize, :serialize
-        alias_method :original_user_serialize, :user_serialize
-        remove_method :user_serialize
-
-        def serialize(record)
-          klass = record.class
-          array = klass.serialize_into_session(record)
-          array.unshift(klass.name)
-        end
-      end
-
-      sign_in_as_user
-      assert warden.authenticated?(:user)
-    ensure
-      Warden::SessionSerializer.class_eval do
-        alias_method :serialize, :original_serialize
-        remove_method :original_serialize
-        alias_method :user_serialize, :original_user_serialize
-        remove_method :original_user_serialize
-      end
-    end
-  end
-
   test 'session id is changed on sign in' do
     get '/users'
     session_id = request.session["session_id"]
@@ -390,24 +367,24 @@ class AuthenticationSessionTest < ActionDispatch::IntegrationTest
   end
 end
 
-class AuthenticationWithScopedViewsTest < ActionDispatch::IntegrationTest
+class AuthenticationWithScopedViewsTest < Devise::IntegrationTest
   test 'renders the scoped view if turned on and view is available' do
-    swap Devise, :scoped_views => true do
+    swap Devise, scoped_views: true do
       assert_raise Webrat::NotFoundError do
         sign_in_as_user
       end
-      assert_match /Special user view/, response.body
+      assert_match %r{Special user view}, response.body
     end
   end
 
-  test 'renders the scoped view if turned on in an specific controller' do
+  test 'renders the scoped view if turned on in a specific controller' do
     begin
       Devise::SessionsController.scoped_views = true
       assert_raise Webrat::NotFoundError do
         sign_in_as_user
       end
 
-      assert_match /Special user view/, response.body
+      assert_match %r{Special user view}, response.body
       assert !Devise::PasswordsController.scoped_views?
     ensure
       Devise::SessionsController.send :remove_instance_variable, :@scoped_views
@@ -415,7 +392,7 @@ class AuthenticationWithScopedViewsTest < ActionDispatch::IntegrationTest
   end
 
   test 'does not render the scoped view if turned off' do
-    swap Devise, :scoped_views => false do
+    swap Devise, scoped_views: false do
       assert_nothing_raised do
         sign_in_as_user
       end
@@ -423,7 +400,7 @@ class AuthenticationWithScopedViewsTest < ActionDispatch::IntegrationTest
   end
 
   test 'does not render the scoped view if not available' do
-    swap Devise, :scoped_views => true do
+    swap Devise, scoped_views: true do
       assert_nothing_raised do
         sign_in_as_admin
       end
@@ -431,24 +408,24 @@ class AuthenticationWithScopedViewsTest < ActionDispatch::IntegrationTest
   end
 end
 
-class AuthenticationOthersTest < ActionDispatch::IntegrationTest
+class AuthenticationOthersTest < Devise::IntegrationTest
   test 'handles unverified requests gets rid of caches' do
-    swap ApplicationController, :allow_forgery_protection => true do
+    swap ApplicationController, allow_forgery_protection: true do
       post exhibit_user_url(1)
-      assert_not warden.authenticated?(:user)
+      refute warden.authenticated?(:user)
 
       sign_in_as_user
       assert warden.authenticated?(:user)
 
       post exhibit_user_url(1)
-      assert_not warden.authenticated?(:user)
+      refute warden.authenticated?(:user)
       assert_equal "User is not authenticated", response.body
     end
   end
 
   test 'uses the custom controller with the custom controller view' do
     get '/admin_area/sign_in'
-    assert_contain 'Sign in'
+    assert_contain 'Log in'
     assert_contain 'Welcome to "admins/sessions" controller!'
     assert_contain 'Welcome to "sessions/new" view!'
   end
@@ -472,29 +449,29 @@ class AuthenticationOthersTest < ActionDispatch::IntegrationTest
 
   test 'sign in with script name' do
     assert_nothing_raised do
-      get new_user_session_path, {}, "SCRIPT_NAME" => "/omg"
-      fill_in "email", :with => "user@test.com"
+      get new_user_session_path, headers: { "SCRIPT_NAME" => "/omg" }
+      fill_in "email", with: "user@test.com"
     end
   end
 
   test 'sign in stub in xml format' do
-    get new_user_session_path(:format => 'xml')
+    get new_user_session_path(format: 'xml')
     assert_match '<?xml version="1.0" encoding="UTF-8"?>', response.body
-    assert_match /<user>.*<\/user>/m, response.body
+    assert_match %r{<user>.*</user>}m, response.body
     assert_match '<email></email>', response.body
     assert_match '<password nil="true"', response.body
   end
 
   test 'sign in stub in json format' do
-    get new_user_session_path(:format => 'json')
+    get new_user_session_path(format: 'json')
     assert_match '{"user":{', response.body
     assert_match '"email":""', response.body
     assert_match '"password":null', response.body
   end
 
   test 'sign in stub in json with non attribute key' do
-    swap Devise, :authentication_keys => [:other_key] do
-      get new_user_session_path(:format => 'json')
+    swap Devise, authentication_keys: [:other_key] do
+      get new_user_session_path(format: 'json')
       assert_match '{"user":{', response.body
       assert_match '"other_key":null', response.body
       assert_match '"password":null', response.body
@@ -502,148 +479,148 @@ class AuthenticationOthersTest < ActionDispatch::IntegrationTest
   end
 
   test 'uses the mapping from router' do
-    sign_in_as_user :visit => "/as/sign_in"
+    sign_in_as_user visit: "/as/sign_in"
     assert warden.authenticated?(:user)
-    assert_not warden.authenticated?(:admin)
+    refute warden.authenticated?(:admin)
   end
 
   test 'sign in with xml format returns xml response' do
     create_user
-    post user_session_path(:format => 'xml'), :user => {:email => "user@test.com", :password => '12345678'}
+    post user_session_path(format: 'xml'), params: { user: {email: "user@test.com", password: '12345678'} }
     assert_response :success
     assert response.body.include? %(<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<user>)
   end
 
   test 'sign in with xml format is idempotent' do
-    get new_user_session_path(:format => 'xml')
+    get new_user_session_path(format: 'xml')
     assert_response :success
 
     create_user
-    post user_session_path(:format => 'xml'), :user => {:email => "user@test.com", :password => '12345678'}
+    post user_session_path(format: 'xml'), params: { user: {email: "user@test.com", password: '12345678'} }
     assert_response :success
 
-    get new_user_session_path(:format => 'xml')
+    get new_user_session_path(format: 'xml')
     assert_response :success
 
-    post user_session_path(:format => 'xml'), :user => {:email => "user@test.com", :password => '12345678'}
+    post user_session_path(format: 'xml'), params: { user: {email: "user@test.com", password: '12345678'} }
     assert_response :success
     assert response.body.include? %(<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n<user>)
   end
 
   test 'sign out with html redirects' do
     sign_in_as_user
-    get destroy_user_session_path
+    delete destroy_user_session_path
     assert_response :redirect
     assert_current_url '/'
 
     sign_in_as_user
-    get destroy_user_session_path(:format => 'html')
+    delete destroy_user_session_path(format: 'html')
     assert_response :redirect
     assert_current_url '/'
   end
 
   test 'sign out with xml format returns no content' do
     sign_in_as_user
-    get destroy_user_session_path(:format => 'xml')
+    delete destroy_user_session_path(format: 'xml')
     assert_response :no_content
-    assert_not warden.authenticated?(:user)
+    refute warden.authenticated?(:user)
   end
 
   test 'sign out with json format returns no content' do
     sign_in_as_user
-    get destroy_user_session_path(:format => 'json')
+    delete destroy_user_session_path(format: 'json')
     assert_response :no_content
-    assert_not warden.authenticated?(:user)
+    refute warden.authenticated?(:user)
   end
 
   test 'sign out with non-navigational format via XHR does not redirect' do
-    swap Devise, :navigational_formats => ['*/*', :html] do
-      sign_in_as_user
-      xml_http_request :get, destroy_user_session_path, {}, { "HTTP_ACCEPT" => "application/json,text/javascript,*/*" } # NOTE: Bug is triggered by combination of XHR and */*.
+    swap Devise, navigational_formats: ['*/*', :html] do
+      sign_in_as_admin
+      get destroy_sign_out_via_get_session_path, xhr: true, headers: { "HTTP_ACCEPT" => "application/json,text/javascript,*/*" } # NOTE: Bug is triggered by combination of XHR and */*.
       assert_response :no_content
-      assert_not warden.authenticated?(:user)
+      refute warden.authenticated?(:user)
     end
   end
 
   # Belt and braces ... Perhaps this test is not necessary?
   test 'sign out with navigational format via XHR does redirect' do
-    swap Devise, :navigational_formats => ['*/*', :html] do
+    swap Devise, navigational_formats: ['*/*', :html] do
       sign_in_as_user
-      xml_http_request :get, destroy_user_session_path, {}, { "HTTP_ACCEPT" => "text/html,*/*" }
+      delete destroy_user_session_path, xhr: true, headers: { "HTTP_ACCEPT" => "text/html,*/*" }
       assert_response :redirect
-      assert_not warden.authenticated?(:user)
+      refute warden.authenticated?(:user)
     end
   end
 end
 
-class AuthenticationKeysTest < ActionDispatch::IntegrationTest
+class AuthenticationKeysTest < Devise::IntegrationTest
   test 'missing authentication keys cause authentication to abort' do
-    swap Devise, :authentication_keys => [:subdomain] do
+    swap Devise, authentication_keys: [:subdomain] do
       sign_in_as_user
-      assert_contain "Invalid email or password."
-      assert_not warden.authenticated?(:user)
+      assert_contain "Invalid Subdomain or password."
+      refute warden.authenticated?(:user)
     end
   end
 
   test 'missing authentication keys cause authentication to abort unless marked as not required' do
-    swap Devise, :authentication_keys => { :email => true, :subdomain => false } do
+    swap Devise, authentication_keys: { email: true, subdomain: false } do
       sign_in_as_user
       assert warden.authenticated?(:user)
     end
   end
 end
 
-class AuthenticationRequestKeysTest < ActionDispatch::IntegrationTest
+class AuthenticationRequestKeysTest < Devise::IntegrationTest
   test 'request keys are used on authentication' do
     host! 'foo.bar.baz'
 
-    swap Devise, :request_keys => [:subdomain] do
-      User.expects(:find_for_authentication).with(:subdomain => 'foo', :email => 'user@test.com').returns(create_user)
+    swap Devise, request_keys: [:subdomain] do
+      User.expects(:find_for_authentication).with(subdomain: 'foo', email: 'user@test.com').returns(create_user)
       sign_in_as_user
       assert warden.authenticated?(:user)
     end
   end
 
   test 'invalid request keys raises NoMethodError' do
-    swap Devise, :request_keys => [:unknown_method] do
+    swap Devise, request_keys: [:unknown_method] do
       assert_raise NoMethodError do
         sign_in_as_user
       end
 
-      assert_not warden.authenticated?(:user)
+      refute warden.authenticated?(:user)
     end
   end
 
   test 'blank request keys cause authentication to abort' do
     host! 'test.com'
 
-    swap Devise, :request_keys => [:subdomain] do
+    swap Devise, request_keys: [:subdomain] do
       sign_in_as_user
-      assert_contain "Invalid email or password."
-      assert_not warden.authenticated?(:user)
+      assert_contain "Invalid Email or password."
+      refute warden.authenticated?(:user)
     end
   end
 
   test 'blank request keys cause authentication to abort unless if marked as not required' do
     host! 'test.com'
 
-    swap Devise, :request_keys => { :subdomain => false } do
+    swap Devise, request_keys: { subdomain: false } do
       sign_in_as_user
       assert warden.authenticated?(:user)
     end
   end
 end
 
-class AuthenticationSignOutViaTest < ActionDispatch::IntegrationTest
+class AuthenticationSignOutViaTest < Devise::IntegrationTest
   def sign_in!(scope)
-    sign_in_as_admin(:visit => send("new_#{scope}_session_path"))
+    sign_in_as_admin(visit: send("new_#{scope}_session_path"))
     assert warden.authenticated?(scope)
   end
 
   test 'allow sign out via delete when sign_out_via provides only delete' do
     sign_in!(:sign_out_via_delete)
     delete destroy_sign_out_via_delete_session_path
-    assert_not warden.authenticated?(:sign_out_via_delete)
+    refute warden.authenticated?(:sign_out_via_delete)
   end
 
   test 'do not allow sign out via get when sign_out_via provides only delete' do
@@ -657,7 +634,7 @@ class AuthenticationSignOutViaTest < ActionDispatch::IntegrationTest
   test 'allow sign out via post when sign_out_via provides only post' do
     sign_in!(:sign_out_via_post)
     post destroy_sign_out_via_post_session_path
-    assert_not warden.authenticated?(:sign_out_via_post)
+    refute warden.authenticated?(:sign_out_via_post)
   end
 
   test 'do not allow sign out via get when sign_out_via provides only post' do
@@ -671,13 +648,13 @@ class AuthenticationSignOutViaTest < ActionDispatch::IntegrationTest
   test 'allow sign out via delete when sign_out_via provides delete and post' do
     sign_in!(:sign_out_via_delete_or_post)
     delete destroy_sign_out_via_delete_or_post_session_path
-    assert_not warden.authenticated?(:sign_out_via_delete_or_post)
+    refute warden.authenticated?(:sign_out_via_delete_or_post)
   end
 
   test 'allow sign out via post when sign_out_via provides delete and post' do
     sign_in!(:sign_out_via_delete_or_post)
     post destroy_sign_out_via_delete_or_post_session_path
-    assert_not warden.authenticated?(:sign_out_via_delete_or_post)
+    refute warden.authenticated?(:sign_out_via_delete_or_post)
   end
 
   test 'do not allow sign out via get when sign_out_via provides delete and post' do
@@ -689,25 +666,41 @@ class AuthenticationSignOutViaTest < ActionDispatch::IntegrationTest
   end
 end
 
-class DoubleAuthenticationRedirectTest < ActionDispatch::IntegrationTest
+class DoubleAuthenticationRedirectTest < Devise::IntegrationTest
   test 'signed in as user redirects when visiting user sign in page' do
     sign_in_as_user
-    get new_user_session_path(:format => :html)
+    get new_user_session_path(format: :html)
     assert_redirected_to '/'
   end
 
   test 'signed in as admin redirects when visiting admin sign in page' do
     sign_in_as_admin
-    get new_admin_session_path(:format => :html)
+    get new_admin_session_path(format: :html)
     assert_redirected_to '/admin_area/home'
   end
 
   test 'signed in as both user and admin redirects when visiting admin sign in page' do
     sign_in_as_user
     sign_in_as_admin
-    get new_user_session_path(:format => :html)
+    get new_user_session_path(format: :html)
     assert_redirected_to '/'
-    get new_admin_session_path(:format => :html)
+    get new_admin_session_path(format: :html)
     assert_redirected_to '/admin_area/home'
   end
 end
+
+class DoubleSignOutRedirectTest < Devise::IntegrationTest
+  test 'sign out after already having signed out redirects to sign in' do
+    sign_in_as_user
+
+    post destroy_sign_out_via_delete_or_post_session_path
+
+    get root_path
+    assert_contain 'Signed out successfully.'
+
+    post destroy_sign_out_via_delete_or_post_session_path
+
+    get root_path
+    assert_contain 'Signed out successfully.'
+  end
+end