authlogic 4.4.2 → 5.0.3

data/test/acts_as_authentic_test/persistence_token_test.rb

@@ -1,62 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-module ActsAsAuthenticTest
-  class PersistenceTokenTest < ActiveSupport::TestCase
-    def test_after_password_set_reset_persistence_token
-      ben = users(:ben)
-      old_persistence_token = ben.persistence_token
-      ben.password = "newpass"
-      assert_not_equal old_persistence_token, ben.persistence_token
-    end
-
-    def test_after_password_verification_reset_persistence_token
-      aaron = users(:aaron)
-      old_persistence_token = aaron.persistence_token
-
-      assert aaron.valid_password?(password_for(aaron))
-      assert_equal old_persistence_token, aaron.reload.persistence_token
-
-      # only update it if it is nil
-      assert aaron.update_attribute(:persistence_token, nil)
-      assert aaron.valid_password?(password_for(aaron))
-      assert_not_equal old_persistence_token, aaron.persistence_token
-    end
-
-    def test_before_validate_reset_persistence_token
-      u = User.new
-      refute u.valid?
-      assert_not_nil u.persistence_token
-    end
-
-    def test_forget_all
-      UserSession.allow_http_basic_auth = true
-
-      http_basic_auth_for(users(:ben)) { UserSession.find }
-      http_basic_auth_for(users(:zack)) { UserSession.find(:ziggity_zack) }
-      assert UserSession.find
-      assert UserSession.find(:ziggity_zack)
-      User.forget_all
-      refute UserSession.find
-      refute UserSession.find(:ziggity_zack)
-    end
-
-    def test_forget
-      UserSession.allow_http_basic_auth = true
-
-      ben = users(:ben)
-      zack = users(:zack)
-      http_basic_auth_for(ben) { UserSession.find }
-      http_basic_auth_for(zack) { UserSession.find(:ziggity_zack) }
-
-      assert ben.reload.logged_in?
-      assert zack.reload.logged_in?
-
-      ben.forget!
-
-      refute UserSession.find
-      assert UserSession.find(:ziggity_zack)
-    end
-  end
-end

data/test/acts_as_authentic_test/restful_authentication_test.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-module ActsAsAuthenticTest
-  class RestfulAuthenticationTest < ActiveSupport::TestCase
-    def setup
-      @old_deprecation_behavior = ::ActiveSupport::Deprecation.behavior
-      ::ActiveSupport::Deprecation.behavior = :silence
-    end
-
-    def teardown
-      ::ActiveSupport::Deprecation.behavior = @old_deprecation_behavior
-    end
-
-    def test_act_like_restful_authentication_config
-      refute User.act_like_restful_authentication
-      refute Employee.act_like_restful_authentication
-
-      User.act_like_restful_authentication = true
-      assert User.act_like_restful_authentication
-      assert_equal Authlogic::CryptoProviders::Sha1, User.crypto_provider
-      assert defined?(::REST_AUTH_SITE_KEY)
-      assert_equal "", ::REST_AUTH_SITE_KEY
-      assert_equal 1, Authlogic::CryptoProviders::Sha1.stretches
-
-      User.act_like_restful_authentication false
-      refute User.act_like_restful_authentication
-
-      User.crypto_provider = Authlogic::CryptoProviders::Sha512
-      User.transition_from_crypto_providers = []
-    end
-
-    def test_transition_from_restful_authentication_config
-      refute User.transition_from_restful_authentication
-      refute Employee.transition_from_restful_authentication
-
-      User.transition_from_restful_authentication = true
-      assert User.transition_from_restful_authentication
-      assert defined?(::REST_AUTH_SITE_KEY)
-      assert_equal "", ::REST_AUTH_SITE_KEY
-      assert_equal 1, Authlogic::CryptoProviders::Sha1.stretches
-
-      User.transition_from_restful_authentication false
-      refute User.transition_from_restful_authentication
-    end
-  end
-end

data/test/acts_as_authentic_test/session_maintenance_test.rb

@@ -1,150 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-module ActsAsAuthenticTest
-  class SessionMaintenanceTest < ActiveSupport::TestCase
-    def setup
-      User.log_in_after_create = true
-      User.log_in_after_password_change = true
-    end
-
-    def test_log_in_after_create_config
-      assert User.log_in_after_create
-      User.log_in_after_create = false
-      refute User.log_in_after_create
-      User.log_in_after_create = true
-      assert User.log_in_after_create
-    end
-
-    def test_log_in_after_password_change_config
-      assert User.log_in_after_password_change
-      User.log_in_after_password_change = false
-      refute User.log_in_after_password_change
-      User.log_in_after_password_change = true
-      assert User.log_in_after_password_change
-    end
-
-    def test_login_after_create
-      User.log_in_after_create = true
-      user = User.create(
-        login: "awesome",
-        password: "saweeeet",
-        password_confirmation: "saweeeet",
-        email: "awesome@awesome.com"
-      )
-      assert user.persisted?
-      assert UserSession.find
-      logged_in_user = UserSession.find.user
-      assert_equal logged_in_user, user
-    end
-
-    def test_no_login_after_create
-      old_user = User.create(
-        login: "awesome",
-        password: "saweeeet",
-        password_confirmation: "saweeeet",
-        email: "awesome@awesome.com"
-      )
-      User.log_in_after_create = false
-      user2 = User.create(
-        login: "awesome2",
-        password: "saweeeet2",
-        password_confirmation: "saweeeet2",
-        email: "awesome2@awesome.com"
-      )
-      assert user2.persisted?
-      logged_in_user = UserSession.find.user
-      assert_not_equal logged_in_user, user2
-      assert_equal logged_in_user, old_user
-    end
-
-    def test_updating_session_with_failed_magic_state
-      ben = users(:ben)
-      ben.confirmed = false
-      ben.password = "newpasswd"
-      ben.password_confirmation = "newpasswd"
-      assert ben.save
-    end
-
-    def test_update_session_after_password_modify
-      User.log_in_after_password_change = true
-      ben = users(:ben)
-      UserSession.create(ben)
-      old_session_key = controller.session["user_credentials"]
-      old_cookie_key = controller.cookies["user_credentials"]
-      ben.password = "newpasswd"
-      ben.password_confirmation = "newpasswd"
-      assert ben.save
-      assert controller.session["user_credentials"]
-      assert controller.cookies["user_credentials"]
-      assert_not_equal controller.session["user_credentials"], old_session_key
-      assert_not_equal controller.cookies["user_credentials"], old_cookie_key
-    end
-
-    def test_no_update_session_after_password_modify
-      User.log_in_after_password_change = false
-      ben = users(:ben)
-      UserSession.create(ben)
-      old_session_key = controller.session["user_credentials"]
-      old_cookie_key = controller.cookies["user_credentials"]
-      ben.password = "newpasswd"
-      ben.password_confirmation = "newpasswd"
-      assert ben.save
-      assert controller.session["user_credentials"]
-      assert controller.cookies["user_credentials"]
-      assert_equal controller.session["user_credentials"], old_session_key
-      assert_equal controller.cookies["user_credentials"], old_cookie_key
-    end
-
-    def test_no_session_update_after_modify
-      ben = users(:ben)
-      UserSession.create(ben)
-      old_session_key = controller.session["user_credentials"]
-      old_cookie_key = controller.cookies["user_credentials"]
-      ben.first_name = "Ben"
-      assert ben.save
-      assert_equal controller.session["user_credentials"], old_session_key
-      assert_equal controller.cookies["user_credentials"], old_cookie_key
-    end
-
-    def test_creating_other_user
-      ben = users(:ben)
-      UserSession.create(ben)
-      old_session_key = controller.session["user_credentials"]
-      old_cookie_key = controller.cookies["user_credentials"]
-      user = User.create(
-        login: "awesome",
-        password: "saweet", # Password is too short, user invalid
-        password_confirmation: "saweet",
-        email: "awesome@saweet.com"
-      )
-      refute user.persisted?
-      assert_equal controller.session["user_credentials"], old_session_key
-      assert_equal controller.cookies["user_credentials"], old_cookie_key
-    end
-
-    def test_updating_other_user
-      ben = users(:ben)
-      UserSession.create(ben)
-      old_session_key = controller.session["user_credentials"]
-      old_cookie_key = controller.cookies["user_credentials"]
-      zack = users(:zack)
-      zack.password = "newpasswd"
-      zack.password_confirmation = "newpasswd"
-      assert zack.save
-      assert_equal controller.session["user_credentials"], old_session_key
-      assert_equal controller.cookies["user_credentials"], old_cookie_key
-    end
-
-    def test_resetting_password_when_logged_out
-      ben = users(:ben)
-      refute UserSession.find
-      ben.password = "newpasswd"
-      ben.password_confirmation = "newpasswd"
-      assert ben.save
-      assert UserSession.find
-      assert_equal ben, UserSession.find.record
-    end
-  end
-end

data/test/acts_as_authentic_test/single_access_test.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-module ActsAsAuthenticTest
-  class SingleAccessTest < ActiveSupport::TestCase
-    def test_change_single_access_token_with_password_config
-      refute User.change_single_access_token_with_password
-      refute Employee.change_single_access_token_with_password
-
-      User.change_single_access_token_with_password = true
-      assert User.change_single_access_token_with_password
-      User.change_single_access_token_with_password false
-      refute User.change_single_access_token_with_password
-    end
-
-    def test_validates_uniqueness_of_single_access_token
-      u = User.new
-      u.single_access_token = users(:ben).single_access_token
-      refute u.valid?
-      refute u.errors[:single_access_token].empty?
-    end
-
-    def test_before_validation_reset_single_access_token
-      u = User.new
-      refute u.valid?
-      assert_not_nil u.single_access_token
-    end
-
-    def test_after_password_set_reset_single_access_token
-      User.change_single_access_token_with_password = true
-
-      ben = users(:ben)
-      old_single_access_token = ben.single_access_token
-      ben.password = "new_pass"
-      assert_not_equal old_single_access_token, ben.single_access_token
-
-      User.change_single_access_token_with_password = false
-    end
-
-    def test_after_password_set_is_not_called
-      ldaper = Ldaper.new
-      assert ldaper.save
-    end
-  end
-end

data/test/adapter_test.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-module Authlogic
-  module ControllerAdapters
-    class AbstractAdapterTest < ActiveSupport::TestCase
-      def test_controller
-        controller = Class.new(MockController) do
-          def controller.an_arbitrary_method
-            "bar"
-          end
-        end.new
-        adapter = Authlogic::ControllerAdapters::AbstractAdapter.new(controller)
-
-        assert_equal controller, adapter.controller
-        assert controller.params.equal?(adapter.params)
-        assert adapter.respond_to?(:an_arbitrary_method)
-        assert_equal "bar", adapter.an_arbitrary_method
-      end
-    end
-  end
-end

data/test/authenticates_many_test.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-class AuthenticatesManyTest < ActiveSupport::TestCase
-  def test_employee_sessions
-    binary_logic = companies(:binary_logic)
-
-    # Drew is a binary_logic employee, authentication succeeds
-    drew = employees(:drew)
-    set_session_for(drew)
-    assert binary_logic.employee_sessions.find
-
-    # Jennifer is not a binary_logic employee, authentication fails
-    jennifer = employees(:jennifer)
-    set_session_for(jennifer)
-    refute binary_logic.employee_sessions.find
-  end
-
-  def test_user_sessions
-    binary_logic = companies(:binary_logic)
-
-    # Ben is a binary_logic user, authentication succeeds
-    ben = users(:ben)
-    set_session_for(ben, binary_logic)
-    assert binary_logic.user_sessions.find
-
-    # Zack is not a binary_logic user, authentication fails
-    zack = users(:zack)
-    set_session_for(zack, binary_logic)
-    refute binary_logic.user_sessions.find
-  end
-end

data/test/config_test.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-class ConfigTest < ActiveSupport::TestCase
-  def setup
-    @klass = Class.new {
-      extend Authlogic::Config
-
-      def self.foobar(value = nil)
-        rw_config(:foobar_field, value, "default_foobar")
-      end
-    }
-
-    @subklass = Class.new(@klass)
-  end
-
-  def test_config
-    assert_equal({}, @klass.acts_as_authentic_config)
-  end
-
-  def test_rw_config_read_with_default
-    assert "default_foobar", @klass.foobar
-  end
-
-  def test_rw_config_write
-    assert_equal "my_foobar", @klass.foobar("my_foobar")
-    assert_equal "my_foobar", @klass.foobar
-
-    assert_equal "my_new_foobar", @klass.foobar("my_new_foobar")
-    assert_equal "my_new_foobar", @klass.foobar
-  end
-
-  def test_subclass_rw_config_write
-    assert_equal "subklass_foobar", @subklass.foobar("subklass_foobar")
-    assert_equal "default_foobar", @klass.foobar
-  end
-end

data/test/crypto_provider_test/aes256_test.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-module CryptoProviderTest
-  class AES256Test < ActiveSupport::TestCase
-    def test_encrypt
-      assert Authlogic::CryptoProviders::AES256.encrypt("mypass")
-    end
-
-    def test_matches
-      hash = Authlogic::CryptoProviders::AES256.encrypt("mypass")
-      assert Authlogic::CryptoProviders::AES256.matches?(hash, "mypass")
-    end
-  end
-end

data/test/crypto_provider_test/bcrypt_test.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-module CryptoProviderTest
-  class BCryptTest < ActiveSupport::TestCase
-    def test_encrypt
-      assert Authlogic::CryptoProviders::BCrypt.encrypt("mypass")
-    end
-
-    def test_matches
-      hash = Authlogic::CryptoProviders::BCrypt.encrypt("mypass")
-      assert Authlogic::CryptoProviders::BCrypt.matches?(hash, "mypass")
-    end
-  end
-end

data/test/crypto_provider_test/scrypt_test.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-module CryptoProviderTest
-  class SCryptTest < ActiveSupport::TestCase
-    def test_encrypt
-      assert Authlogic::CryptoProviders::SCrypt.encrypt("mypass")
-    end
-
-    def test_matches
-      hash = Authlogic::CryptoProviders::SCrypt.encrypt("mypass")
-      assert Authlogic::CryptoProviders::SCrypt.matches?(hash, "mypass")
-    end
-  end
-end