authlogic 4.4.2 → 5.0.0

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

data/test/crypto_provider_test/sha1_test.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-module CryptoProviderTest
-  class Sha1Test < ActiveSupport::TestCase
-    def test_encrypt
-      assert Authlogic::CryptoProviders::Sha1.encrypt("mypass")
-    end
-
-    def test_matches
-      hash = Authlogic::CryptoProviders::Sha1.encrypt("mypass")
-      assert Authlogic::CryptoProviders::Sha1.matches?(hash, "mypass")
-    end
-
-    def test_old_restful_authentication_passwords
-      password = "test"
-      salt = "7e3041ebc2fc05a40c60028e2c4901a81035d3cd"
-      digest = "00742970dc9e6319f8019fd54864d3ea740f04b1"
-      Authlogic::CryptoProviders::Sha1.stretches = 1
-      assert Authlogic::CryptoProviders::Sha1.matches?(digest, nil, salt, password, nil)
-      Authlogic::CryptoProviders::Sha1.stretches = 10
-    end
-  end
-end

data/test/crypto_provider_test/sha256_test.rb

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

data/test/crypto_provider_test/sha512_test.rb

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

data/test/crypto_provider_test/wordpress_test.rb

@@ -1,26 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-::ActiveSupport::Deprecation.silence do
-  require "authlogic/crypto_providers/wordpress"
-end
-
-module CryptoProviderTest
-  class WordpressTest < ActiveSupport::TestCase
-    def test_matches
-      plain = "banana"
-      salt = "aaa"
-      crypted = "xxx0nope"
-      # I couldn't figure out how to even execute this method without it
-      # crashing. Maybe, when Jeffry wrote it in 2009, `Digest::MD5.digest`
-      # worked differently. He was probably using ruby 1.9 back then.
-      # Given that I can't even figure out how to run it, and for all the other
-      # reasons I've given in `wordpress.rb`, I'm just going to deprecate
-      # the whole file. -Jared 2018-04-09
-      assert_raises(NoMethodError) {
-        Authlogic::CryptoProviders::Wordpress.matches?(crypted, plain, salt)
-      }
-    end
-  end
-end

data/test/fixtures/companies.yml

@@ -1,5 +0,0 @@
-binary_logic:
-  name: Binary Logic
-
-logic_over_data:
-  name: Logic Over Data

data/test/fixtures/employees.yml

@@ -1,17 +0,0 @@
-drew:
-  company: binary_logic
-  email: dgainor@binarylogic.com
-  password_salt: <%= salt = Authlogic::Random.hex_token %>
-  crypted_password: '<%= Employee.crypto_provider.encrypt("drewrocks" + salt) %>'
-  persistence_token: 5273d85ed156e9dbd6a7c1438d319ef8c8d41dd24368db6c222de11346c7b11e53ee08d45ecf619b1c1dc91233d22b372482b751b066d0a6f6f9bac42eacaabf
-  first_name: Drew
-  last_name: Gainor
-
-jennifer:
-  company: logic_over_data
-  email: jjohnson@logicoverdata.com
-  password_salt: <%= salt = Authlogic::Random.hex_token %>
-  crypted_password: '<%= Employee.crypto_provider.encrypt("jenniferocks" + salt) %>'
-  persistence_token: 2be52a8f741ad00056e6f94eb6844d5316527206da7a3a5e3d0e14d19499ef9fe4c47c89b87febb59a2b41a69edfb4733b6b79302040f3de83f297c6991c75a2
-  first_name: Jennifer
-  last_name: Johnson

data/test/fixtures/projects.yml

@@ -1,3 +0,0 @@
-web_services:
-  name: web services
-  users: ben, zack

data/test/fixtures/users.yml

@@ -1,41 +0,0 @@
-# NB :ben and :zack use the legacy crypto provider (Sha512) ... when they're
-# tested for valid_password?() it will transition their password
-# (re: test/libs/user.rb). This could have unintended side-effects (like auto-
-# resetting their persistence token when checking password) -- one solution
-# is to just switch in users(:aaron) for those tests.
-ben:
-  company: binary_logic
-  projects: web_services
-  login: bjohnson
-  password_salt: <%= salt = Authlogic::Random.hex_token %>
-  crypted_password: <%= Authlogic::CryptoProviders::Sha512.encrypt("benrocks" + salt) %>
-  persistence_token: 6cde0674657a8a313ce952df979de2830309aa4c11ca65805dd00bfdc65dbcc2f5e36718660a1d2e68c1a08c276d996763985d2f06fd3d076eb7bc4d97b1e317
-  single_access_token: <%= Authlogic::Random.friendly_token %>
-  perishable_token: <%= Authlogic::Random.friendly_token %>
-  email: bjohnson@binarylogic.com
-  first_name: Ben
-  last_name: Johnson
-
-zack:
-  company: logic_over_data
-  projects: web_services
-  login: zackham
-  password_salt: <%= salt = Authlogic::Random.hex_token %>
-  crypted_password: <%= Authlogic::CryptoProviders::Sha512.encrypt("zackrocks" + salt) %>
-  persistence_token: fd3c2d5ce09ab98e7547d21f1b3dcf9158a9a19b5d3022c0402f32ae197019fce3fdbc6614d7ee57d719bae53bb089e30edc9e5d6153e5bc3afca0ac1d320342
-  single_access_token: <%= Authlogic::Random.friendly_token %>
-  email: zham@ziggityzack.com
-  first_name: Zack
-  last_name: Ham
-
-aaron:
-  company: cigital
-  projects: web_services
-  login: abedra
-  crypted_password: <%= Authlogic::CryptoProviders::SCrypt.encrypt("aaronrocks") %>
-  persistence_token: e3d853f5aa0dacac5c257d03c4e097a3a7f51b182a8fc4f62096d05e939b019855aff0290157ac854e4195f13284ff5223f1996d0fd073e7e360171de54db278
-  single_access_token: <%= Authlogic::Random.friendly_token %>
-  perishable_token: <%= Authlogic::Random.friendly_token %>
-  email: abedra@cigital.com
-  first_name: Aaron
-  last_name: Bedra

data/test/i18n/lol.yml

@@ -1,4 +0,0 @@
-lol:
-  authlogic:
-    error_messages:
-      email_invalid: LOL email should be valid.

data/test/i18n_test.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-class I18nTest < ActiveSupport::TestCase
-  def test_uses_authlogic_as_scope_by_default
-    assert_equal :authlogic, Authlogic::I18n.scope
-  end
-
-  def test_can_set_scope
-    assert_nothing_raised { Authlogic::I18n.scope = %i[a b] }
-    assert_equal %i[a b], Authlogic::I18n.scope
-    Authlogic::I18n.scope = :authlogic
-  end
-
-  def test_uses_built_in_translator_by_default
-    assert_equal Authlogic::I18n::Translator, Authlogic::I18n.translator.class
-  end
-
-  def test_can_set_custom_translator
-    old_translator = Authlogic::I18n.translator
-
-    assert_nothing_raised do
-      Authlogic::I18n.translator = Class.new do
-        def translate(key, _options = {})
-          "Translated: #{key}"
-        end
-      end.new
-    end
-
-    assert_equal "Translated: x", Authlogic::I18n.translate(:x)
-
-    Authlogic::I18n.translator = old_translator
-  end
-end

data/test/libs/affiliate.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-class Affiliate < ActiveRecord::Base
-  acts_as_authentic do |c|
-    c.crypted_password_field = :pw_hash
-  end
-
-  belongs_to :company
-end

data/test/libs/company.rb

@@ -1,8 +0,0 @@
-# frozen_string_literal: true
-
-class Company < ActiveRecord::Base
-  authenticates_many :employee_sessions
-  authenticates_many :user_sessions, scope_cookies: true
-  has_many :employees, dependent: :destroy
-  has_many :users, dependent: :destroy
-end

data/test/libs/employee.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-class Employee < ActiveRecord::Base
-  acts_as_authentic do |c|
-    c.crypto_provider Authlogic::CryptoProviders::AES256
-  end
-
-  belongs_to :company
-end

data/test/libs/employee_session.rb

@@ -1,4 +0,0 @@
-# frozen_string_literal: true
-
-class EmployeeSession < Authlogic::Session::Base
-end

data/test/libs/ldaper.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-class Ldaper < ActiveRecord::Base
-  acts_as_authentic
-end

data/test/libs/project.rb

@@ -1,5 +0,0 @@
-# frozen_string_literal: true
-
-class Project < ActiveRecord::Base
-  has_and_belongs_to_many :users
-end

data/test/libs/user.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-class User < ActiveRecord::Base
-  acts_as_authentic do |c|
-    c.transition_from_crypto_providers Authlogic::CryptoProviders::Sha512
-  end
-  belongs_to :company
-  has_and_belongs_to_many :projects
-end

data/test/libs/user_session.rb

@@ -1,27 +0,0 @@
-# frozen_string_literal: true
-
-class UserSession < Authlogic::Session::Base
-end
-
-class BackOfficeUserSession < Authlogic::Session::Base
-end
-
-class WackyUserSession < Authlogic::Session::Base
-  attr_accessor :counter
-  authenticate_with User
-
-  def initialize
-    @counter = 0
-    super
-  end
-
-  def persist_by_false
-    self.counter += 1
-    false
-  end
-
-  def persist_by_true
-    self.counter += 1
-    true
-  end
-end

data/test/random_test.rb

@@ -1,15 +0,0 @@
-# frozen_string_literal: true
-
-require "test_helper"
-
-class RandomTest < ActiveSupport::TestCase
-  def test_that_hex_tokens_are_unique
-    tokens = Array.new(100) { Authlogic::Random.hex_token }
-    assert_equal tokens.size, tokens.uniq.size
-  end
-
-  def test_that_friendly_tokens_are_unique
-    tokens = Array.new(100) { Authlogic::Random.friendly_token }
-    assert_equal tokens.size, tokens.uniq.size
-  end
-end