nulogy-authlogic 3.1.0.1

data/lib/authlogic/test_case/mock_cookie_jar.rb

@@ -0,0 +1,14 @@
+module Authlogic
+  module TestCase
+    class MockCookieJar < Hash # :nodoc:
+      def [](key)
+        hash = super
+        hash && hash[:value]
+      end
+  
+      def delete(key, options = {})
+        super(key)
+      end
+    end
+  end
+end

data/lib/authlogic/test_case/mock_logger.rb

@@ -0,0 +1,10 @@
+module Authlogic
+  module TestCase
+    # Simple class to replace real loggers, so that we can raise any errors being logged.
+    class MockLogger
+      def error(message)
+        raise message
+      end
+    end
+  end
+end

data/lib/authlogic/test_case/mock_request.rb

@@ -0,0 +1,19 @@
+module Authlogic
+  module TestCase
+    class MockRequest # :nodoc:
+      attr_accessor :controller
+      
+      def initialize(controller)
+        self.controller = controller
+      end
+      
+      def remote_ip
+        (controller && controller.respond_to?(:env) && controller.env.is_a?(Hash) && controller.env['REMOTE_ADDR']) || "1.1.1.1"
+      end
+      
+      private
+        def method_missing(*args, &block)
+        end
+    end
+  end
+end

data/lib/authlogic/test_case/rails_request_adapter.rb

@@ -0,0 +1,30 @@
+module Authlogic
+  module TestCase
+    # Adapts authlogic to work with the @request object when testing. This way Authlogic can set cookies and what not before
+    # a request is made, ultimately letting you log in users in functional tests.
+    class RailsRequestAdapter < ControllerAdapters::AbstractAdapter
+      def authenticate_with_http_basic(&block)
+      end
+      
+      def cookies
+        new_cookies = MockCookieJar.new
+        super.each do |key, value|
+          new_cookies[key] = value[:value]
+        end
+        new_cookies
+      end
+      
+      def cookie_domain
+        nil
+      end
+      
+      def request
+        @request ||= MockRequest.new(controller)
+      end
+      
+      def request_content_type
+        request.format.to_s
+      end
+    end
+  end
+end

data/lib/generators/authlogic/USAGE

@@ -0,0 +1,8 @@
+Description:
+    Create session model that represents the user’s current session.
+
+Example:
+    rails generate authlogic:session UserSession
+
+    This will create:
+        Model UserSession in app/models directory 

data/lib/generators/authlogic/session_generator.rb

@@ -0,0 +1,14 @@
+module Authlogic
+  class SessionGenerator < Rails::Generators::Base
+    source_root File.expand_path('../templates', __FILE__)
+    argument :session_class_name, :type => :string, :default => "Session"
+
+    def self.banner
+      "rails generate authlogic:#{generator_name} #{self.arguments.map{ |a| a.usage }.join(' ')} [options]"
+    end
+  
+    def generate_session
+      template "session.rb", "app/models/#{session_class_name.underscore}.rb"
+    end
+  end
+end

data/lib/generators/authlogic/templates/session.rb

@@ -0,0 +1,2 @@
+class <%= session_class_name %> < Authlogic::Session::Base
+end

data/rails/init.rb

@@ -0,0 +1 @@
+require "authlogic"

data/shoulda_macros/authlogic.rb

@@ -0,0 +1,69 @@
+# Test::Unit
+# Place this file into your test/shoulda_macros directory
+#
+# Example:
+# 
+# class UserTest
+#   should_have_authlogic
+# end
+#
+# Rspec
+# Place this file into your spec/support/shoulda directory
+#
+# Example:
+#
+# describe User do
+#   it { should have_authlogic }
+# end
+
+module Authlogic
+  module Shoulda
+
+    module Matchers
+      def have_authlogic
+        HaveAuthlogic.new
+      end
+      alias_method :be_authentic, :have_authlogic
+
+      class HaveAuthlogic
+
+        def matches?(subject)
+          subject.respond_to?(:password=) && subject.respond_to?(:valid_password?)
+        end
+
+        def failure_message
+          "Add the line 'acts_as_authentic' to your model"
+        end
+
+        def description
+          "have Authlogic"
+        end
+      end
+      
+    end
+    
+    module Macros
+      include Matchers
+      
+      def should_have_authlogic
+        klass = described_type rescue model_class
+        matcher = HaveAuthlogic.new
+        
+        should matcher.description do
+          assert matcher.matches?(klass.new), matcher.failure_message
+        end
+      end
+      alias_method :should_be_authentic, :should_have_authlogic
+      
+    end
+    
+  end
+end
+
+if defined? Spec
+  Spec::Runner.configure do |config|
+    config.include(Authlogic::Shoulda::Matchers)
+  end
+else
+  Test::Unit::TestCase.class_eval { extend Authlogic::Shoulda::Macros }
+end

data/test/acts_as_authentic_test/base_test.rb

@@ -0,0 +1,18 @@
+require 'test_helper'
+
+module ActsAsAuthenticTest
+  class BaseTest < ActiveSupport::TestCase
+    def test_acts_as_authentic
+      assert_nothing_raised do
+        User.acts_as_authentic do
+        end
+      end
+    end
+    
+    def test_acts_as_authentic_with_old_config
+      assert_raise(ArgumentError) do
+        User.acts_as_authentic({})
+      end
+    end
+  end
+end

data/test/acts_as_authentic_test/email_test.rb

@@ -0,0 +1,116 @@
+require 'test_helper'
+
+module ActsAsAuthenticTest
+  class EmailTest < ActiveSupport::TestCase
+    def test_email_field_config
+      assert_equal :email, User.email_field
+      assert_equal :email, Employee.email_field
+
+      User.email_field = :nope
+      assert_equal :nope, User.email_field
+      User.email_field :email
+      assert_equal :email, User.email_field
+    end
+
+    def test_validate_email_field_config
+      assert User.validate_email_field
+      assert Employee.validate_email_field
+
+      User.validate_email_field = false
+      assert !User.validate_email_field
+      User.validate_email_field true
+      assert User.validate_email_field
+    end
+
+    def test_validates_length_of_email_field_options_config
+      assert_equal({:maximum => 100}, User.validates_length_of_email_field_options)
+      assert_equal({:maximum => 100}, Employee.validates_length_of_email_field_options)
+
+      User.validates_length_of_email_field_options = {:yes => "no"}
+      assert_equal({:yes => "no"}, User.validates_length_of_email_field_options)
+      User.validates_length_of_email_field_options({:within => 6..100})
+      assert_equal({:within => 6..100}, User.validates_length_of_email_field_options)
+    end
+
+    def test_validates_format_of_email_field_options_config
+      email_invalid_msg = I18n.t('error_messages.email_invalid', :default => "should look like an email address.")
+      default = {:with => Authlogic::Regex.email, :message => email_invalid_msg}
+
+      user_options = User.validates_format_of_email_field_options
+      assert_equal default[:with], user_options[:with]
+      assert_equal email_invalid_msg, user_options[:message].call
+
+      employee_options = Employee.validates_format_of_email_field_options
+      assert_equal default[:with], employee_options[:with]
+      assert_equal email_invalid_msg, employee_options[:message].call
+
+      User.validates_format_of_email_field_options = {:yes => "no"}
+      assert_equal({:yes => "no"}, User.validates_format_of_email_field_options)
+      User.validates_format_of_email_field_options default
+      assert_equal default, User.validates_format_of_email_field_options
+    end
+
+    def test_validates_uniqueness_of_email_field_options_config
+      default = {:case_sensitive => false, :scope => Employee.validations_scope, :if => "#{Employee.email_field}_changed?".to_sym}
+      assert_equal default, Employee.validates_uniqueness_of_email_field_options
+
+      Employee.validates_uniqueness_of_email_field_options = {:yes => "no"}
+      assert_equal({:yes => "no"}, Employee.validates_uniqueness_of_email_field_options)
+      Employee.validates_uniqueness_of_email_field_options default
+      assert_equal default, Employee.validates_uniqueness_of_email_field_options
+    end
+
+    def test_validates_length_of_email_field
+      u = User.new
+      u.email = "a@a.a"
+      assert !u.valid?
+      assert u.errors[:email].size > 0
+
+      u.email = "a@a.com"
+      assert !u.valid?
+      assert u.errors[:email].size == 0
+    end
+
+    def test_validates_format_of_email_field
+      u = User.new
+      u.email = "aaaaaaaaaaaaa"
+      u.valid?
+      assert u.errors[:email].size > 0
+
+      u.email = "a@a.com"
+      u.valid?
+      assert u.errors[:email].size == 0
+
+      u.email = "damien+test1...etc..@mydomain.com"
+      u.valid?
+      assert u.errors[:email].size == 0
+
+      u.email = "dakota.dux+1@gmail.com"
+      u.valid?
+      assert u.errors[:email].size == 0
+
+      u.email = "dakota.d'ux@gmail.com"
+      u.valid?
+      assert u.errors[:email].size == 0
+      
+      u.email = "<script>alert(123);</script>\nnobody@example.com"
+      assert !u.valid?
+      assert u.errors[:email].size > 0
+    end
+
+    def test_validates_uniqueness_of_email_field
+      u = User.new
+      u.email = "bjohnson@binarylogic.com"
+      assert !u.valid?
+      assert u.errors[:email].size > 0
+
+      u.email = "BJOHNSON@binarylogic.com"
+      assert !u.valid?
+      assert u.errors[:email].size > 0
+
+      u.email = "a@a.com"
+      assert !u.valid?
+      assert u.errors[:email].size == 0
+    end
+  end
+end

data/test/acts_as_authentic_test/logged_in_status_test.rb

@@ -0,0 +1,50 @@
+require 'test_helper'
+
+module ActsAsAuthenticTest
+  class LoggedInStatusTest < ActiveSupport::TestCase
+    ERROR_MSG = 'Multiple calls to %s should result in different relations'
+    
+    def test_logged_in_timeout_config
+      assert_equal 10.minutes.to_i, User.logged_in_timeout
+      assert_equal 10.minutes.to_i, Employee.logged_in_timeout
+      
+      User.logged_in_timeout = 1.hour
+      assert_equal 1.hour.to_i, User.logged_in_timeout
+      User.logged_in_timeout 10.minutes
+      assert_equal 10.minutes.to_i, User.logged_in_timeout
+    end
+    
+    def test_named_scope_logged_in
+      # Testing that the scope returned differs, because the time it was called should be 
+      # slightly different. This is an attempt to make sure the scope is lambda wrapped 
+      # so that it is re-evaluated every time its called. My biggest concern is that the
+      # test happens so fast that the test fails... I just don't know a better way to test it!
+      assert User.logged_in.where_values != User.logged_in.where_values, ERROR_MSG % '#logged_in'
+      
+      assert_equal 0, User.logged_in.count
+      User.first.update_attribute(:last_request_at, Time.now)
+      assert_equal 1, User.logged_in.count
+    end
+    
+    def test_named_scope_logged_out
+      # Testing that the scope returned differs, because the time it was called should be 
+      # slightly different. This is an attempt to make sure the scope is lambda wrapped 
+      # so that it is re-evaluated every time its called. My biggest concern is that the
+      # test happens so fast that the test fails... I just don't know a better way to test it!
+      assert User.logged_in.where_values != User.logged_out.where_values, ERROR_MSG % '#logged_out'
+      
+      assert_equal 2, User.logged_out.count
+      User.first.update_attribute(:last_request_at, Time.now)
+      assert_equal 1, User.logged_out.count
+    end
+    
+    def test_logged_in_logged_out
+      u = User.first
+      assert !u.logged_in?
+      assert u.logged_out?
+      u.last_request_at = Time.now
+      assert u.logged_in?
+      assert !u.logged_out?
+    end
+  end
+end

data/test/acts_as_authentic_test/login_test.rb

@@ -0,0 +1,116 @@
+require 'test_helper'
+
+module ActsAsAuthenticTest
+  class LoginTest < ActiveSupport::TestCase
+    def test_login_field_config
+      assert_equal :login, User.login_field
+      assert_nil Employee.login_field
+      
+      User.login_field = :nope
+      assert_equal :nope, User.login_field
+      User.login_field :login
+      assert_equal :login, User.login_field
+    end
+    
+    def test_validate_login_field_config
+      assert User.validate_login_field
+      assert Employee.validate_login_field
+      
+      User.validate_login_field = false
+      assert !User.validate_login_field
+      User.validate_login_field true
+      assert User.validate_login_field
+    end
+    
+    def test_validates_length_of_login_field_options_config
+      assert_equal({:within => 3..100}, User.validates_length_of_login_field_options)
+      assert_equal({:within => 3..100}, Employee.validates_length_of_login_field_options)
+      
+      User.validates_length_of_login_field_options = {:yes => "no"}
+      assert_equal({:yes => "no"}, User.validates_length_of_login_field_options)
+      User.validates_length_of_login_field_options({:within => 3..100})
+      assert_equal({:within => 3..100}, User.validates_length_of_login_field_options)
+    end
+    
+    def test_validates_format_of_login_field_options_config
+      login_invalid_msg = I18n.t('error_messages.login_invalid', :default => "should use only letters, numbers, spaces, and .-_@ please.")
+      default = {:with => /\A\w[\w\.+\-_@ ]+$/, :message => login_invalid_msg}
+
+      user_options = User.validates_format_of_login_field_options
+      assert_equal default[:with], user_options[:with]
+      assert_equal login_invalid_msg, user_options[:message].call
+
+      employee_options = Employee.validates_format_of_login_field_options
+      assert_equal default[:with], employee_options[:with]
+      assert_equal login_invalid_msg, employee_options[:message].call
+      
+      User.validates_format_of_login_field_options = {:yes => "no"}
+      assert_equal({:yes => "no"}, User.validates_format_of_login_field_options)
+      User.validates_format_of_login_field_options default
+      assert_equal default, User.validates_format_of_login_field_options
+    end
+    
+    def test_validates_uniqueness_of_login_field_options_config
+      default = {:case_sensitive => false, :scope => User.validations_scope, :if => "#{User.login_field}_changed?".to_sym}
+      assert_equal default, User.validates_uniqueness_of_login_field_options
+      
+      User.validates_uniqueness_of_login_field_options = {:yes => "no"}
+      assert_equal({:yes => "no"}, User.validates_uniqueness_of_login_field_options)
+      User.validates_uniqueness_of_login_field_options default
+      assert_equal default, User.validates_uniqueness_of_login_field_options
+    end
+    
+    def test_validates_length_of_login_field
+      u = User.new
+      u.login = "a"
+      assert !u.valid?
+      assert u.errors[:login].size > 0
+      
+      u.login = "aaaaaaaaaa"
+      assert !u.valid?
+      assert u.errors[:login].size == 0
+    end
+    
+    def test_validates_format_of_login_field
+      u = User.new
+      u.login = "fdsf@^&*"
+      assert !u.valid?
+      assert u.errors[:login].size > 0
+      
+      u.login = "fdsfdsfdsfdsfs"
+      assert !u.valid?
+      assert u.errors[:login].size == 0
+      
+      u.login = "dakota.dux+1@gmail.com"
+      assert !u.valid?
+      assert u.errors[:login].size == 0
+    end
+    
+    def test_validates_uniqueness_of_login_field
+      u = User.new
+      u.login = "bjohnson"
+      assert !u.valid?
+      assert u.errors[:login].size > 0
+      
+      u.login = "BJOHNSON"
+      assert !u.valid?
+      assert u.errors[:login].size > 0
+      
+      u.login = "fdsfdsf"
+      assert !u.valid?
+      assert u.errors[:login].size == 0
+    end
+    
+    def test_find_by_smart_case_login_field
+      ben = users(:ben)
+      assert_equal ben, User.find_by_smart_case_login_field("bjohnson")
+      assert_equal ben, User.find_by_smart_case_login_field("BJOHNSON")
+      assert_equal ben, User.find_by_smart_case_login_field("Bjohnson")
+      
+      drew = employees(:drew)
+      assert_equal drew, Employee.find_by_smart_case_login_field("dgainor@binarylogic.com")
+      assert_equal drew, Employee.find_by_smart_case_login_field("Dgainor@binarylogic.com")
+      assert_equal drew, Employee.find_by_smart_case_login_field("DGAINOR@BINARYLOGIC.COM")
+    end
+  end
+end