clearance 1.0.1 → 1.1.0

data/lib/clearance/session_status.rb

@@ -0,0 +1,19 @@
+module Clearance
+  class SuccessStatus
+    def success?
+      true
+    end
+  end
+
+  class FailureStatus
+    attr_reader :failure_message
+
+    def initialize(failure_message)
+      @failure_message = failure_message
+    end
+
+    def success?
+      false
+    end
+  end
+end

data/lib/clearance/sign_in_guard.rb

@@ -0,0 +1,36 @@
+require 'clearance/session_status'
+
+module Clearance
+  class SignInGuard
+    def initialize(session, stack = [])
+      @session = session
+      @stack = stack
+    end
+
+    def success
+      SuccessStatus.new
+    end
+
+    def failure(message)
+      FailureStatus.new(message)
+    end
+
+    def next_guard
+      stack.call
+    end
+
+
+    private
+    attr_reader :stack, :session
+
+
+    def signed_in?
+      session.signed_in?
+    end
+
+    def current_user
+      session.current_user
+    end
+
+  end
+end

data/lib/clearance/testing/application.rb

@@ -28,6 +28,7 @@ module Clearance
 
       if Clearance::Testing.rails4?
         config.paths.add 'config/routes.rb', with: "#{APP_ROOT}/config/routes.rb"
+        config.secret_key_base = 'SECRET_KEY_BASE'
       else
         config.paths.add 'config/routes', with: "#{APP_ROOT}/config/routes.rb"
       end
@@ -36,7 +37,7 @@ module Clearance
         initialize!
       end
 
-      def initialize!
+      def initialize!(&block)
         FileUtils.mkdir_p(Rails.root.join('db').to_s)
         super unless @initialized
       end

data/lib/clearance/user.rb

@@ -43,7 +43,7 @@ module Clearance
 
       included do
         validates :email,
-          email: true,
+          email: { strict_mode: true },
           presence: true,
           uniqueness: { allow_blank: true },
           unless: :email_optional?

data/lib/clearance/version.rb

@@ -1,3 +1,3 @@
 module Clearance
-  VERSION = '1.0.1'
+  VERSION = '1.1.0'
 end

data/spec/clearance/session_spec.rb

@@ -17,7 +17,6 @@ describe Clearance::Session do
   end
 
   it 'returns nil for an unknown user' do
-    user = create(:user)
     env = env_with_remember_token('bogus')
     session = Clearance::Session.new(env)
     session.should be_signed_out
@@ -38,6 +37,38 @@ describe Clearance::Session do
       expect(session.current_user).to eq user
     end
 
+    context 'with a block' do
+      it 'passes the success status to the block when sign in succeeds' do
+        success_status = stub_status(Clearance::SuccessStatus, true)
+        success_lambda = stub_callable
+
+        session.sign_in build(:user), &success_lambda
+
+        expect(success_lambda).to have_been_called.with(success_status)
+      end
+
+      it 'passes the failure status to the block when sign in fails' do
+        failure_status = stub_status(Clearance::FailureStatus, false)
+        failure_lambda = stub_callable
+
+        session.sign_in nil, &failure_lambda
+
+        expect(failure_lambda).to have_been_called.with(failure_status)
+      end
+
+      def stub_status(status_class, success)
+        stub('status', success?: success).tap do |status|
+          status_class.stubs(new: status)
+        end
+      end
+
+      def stub_callable
+        lambda {}.tap do |callable|
+          callable.stubs(:call)
+        end
+      end
+    end
+
     context 'with nil argument' do
       it 'assigns current_user' do
         session.sign_in nil
@@ -45,6 +76,57 @@ describe Clearance::Session do
         expect(session.current_user).to be_nil
       end
     end
+
+    context 'with a sign in stack' do
+
+      it 'runs the first guard' do
+        guard = stub_sign_in_guard(succeed: true)
+        user = build(:user)
+
+        session.sign_in user
+
+        expect(guard).to have_received(:call)
+      end
+
+      it 'will not sign in the user if the guard stack fails' do
+        stub_sign_in_guard(succeed: false)
+        user = build(:user)
+
+        session.sign_in user
+
+        expect(session.instance_variable_get("@cookies")).to be_nil
+        expect(session.current_user).to be_nil
+      end
+
+
+      def stub_sign_in_guard(options)
+        session_status = stub_status(options.fetch(:succeed))
+
+        stub('guard', call: session_status).tap do |guard|
+          Clearance.configuration.sign_in_guards << stub_guard_class(guard)
+        end
+      end
+
+      def stub_default_sign_in_guard
+        stub(:default_sign_in_guard).tap do |sign_in_guard|
+          Clearance::DefaultSignInGuard.stubs(:new).with(session).returns(sign_in_guard)
+        end
+      end
+
+      def stub_guard_class(guard)
+        stub(:guard_class).tap do |guard_class|
+          guard_class.stubs(:new).with(session, stub_default_sign_in_guard).returns(guard)
+        end
+      end
+
+      def stub_status(success)
+        stub('status', success?: success)
+      end
+
+      after do
+        Clearance.configuration.sign_in_guards = []
+      end
+    end
   end
 
   context 'if httponly is set' do
@@ -74,54 +156,139 @@ describe Clearance::Session do
     end
   end
 
-  it 'sets a remember token cookie with a default expiration of 1 year from now' do
-    user = create(:user)
-    headers = {}
-    session = Clearance::Session.new(env_without_remember_token)
-    session.sign_in user
-    session.add_cookie_to_headers headers
-    headers.should set_cookie('remember_token', user.remember_token, 1.year.from_now)
-  end
+  describe 'remember token cookie expiration' do
+    context 'default configuration' do
+      it 'is set to 1 year from now' do
+        user = stub('User', remember_token: '123abc')
+        headers = {}
+        session = Clearance::Session.new(env_without_remember_token)
+        session.sign_in user
+        session.add_cookie_to_headers headers
+        headers.should set_cookie('remember_token', user.remember_token, 1.year.from_now)
+      end
+    end
 
-  it 'sets a remember token cookie with a custom expiration' do
-    custom_expiration = 1.day.from_now
+    context 'configured with lambda taking no arguments' do
+      it 'logs a deprecation warning' do
+        expiration = -> { Time.now }
+        with_custom_expiration expiration do
+          session = Clearance::Session.new(env_without_remember_token)
+          session.stubs(:warn)
+          session.add_cookie_to_headers headers
+          expect(session).to have_received(:warn).once
+        end
+      end
 
-    with_custom_expiration 1.day.from_now do
-      user = create(:user)
-      headers = {}
-      session = Clearance::Session.new(env_without_remember_token)
-      session.sign_in user
-      session.add_cookie_to_headers headers
-      headers.should set_cookie('remember_token', user.remember_token, 1.day.from_now)
-      Clearance.configuration.cookie_expiration.call.should be_within(100).
-        of(1.year.from_now)
+      it 'is set to the value of the evaluated lambda' do
+        expires_at = -> { 1.day.from_now }
+        with_custom_expiration expires_at do
+          user = stub('User', remember_token: '123abc')
+          headers = {}
+          session = Clearance::Session.new(env_without_remember_token)
+          session.sign_in user
+          session.stubs(:warn)
+          session.add_cookie_to_headers headers
+          headers.should set_cookie('remember_token', user.remember_token, expires_at.call)
+        end
+      end
+    end
+
+    context 'configured with lambda taking one argument' do
+      it 'it can use other cookies to set the value of the expires token' do
+        remembered_expires = 12.hours.from_now
+        expires_at = ->(cookies) { cookies['remember_me'] ? remembered_expires : nil }
+        with_custom_expiration expires_at do
+          user = stub('User', remember_token: '123abc')
+          headers = {}
+          session = Clearance::Session.new(env_with_cookies(remember_me: 'true'))
+          session.sign_in user
+          session.add_cookie_to_headers headers
+          headers.should set_cookie('remember_token', user.remember_token, remembered_expires)
+        end
+      end
     end
   end
 
-  context 'if secure_cookie is set' do
-    before do
-      Clearance.configuration.secure_cookie = true
-      session.sign_in(user)
+  describe 'secure cookie option' do
+    context 'when not set' do
+      before do
+        session.sign_in(user)
+      end
+
+      it 'sets a standard cookie' do
+        session.add_cookie_to_headers(headers)
+
+        headers['Set-Cookie'].should_not =~ /remember_token=.+; secure/
+      end
     end
 
-    it 'sets a secure cookie' do
-      session.add_cookie_to_headers(headers)
+    context 'when set' do
+      before do
+        Clearance.configuration.secure_cookie = true
+        session.sign_in(user)
+      end
+
+      it 'sets a secure cookie' do
+        session.add_cookie_to_headers(headers)
+
+        headers['Set-Cookie'].should =~ /remember_token=.+; secure/
+      end
 
-      headers['Set-Cookie'].should =~ /remember_token=.+; secure/
+      after { restore_default_config }
     end
+  end
 
-    after { restore_default_config }
+  describe 'cookie domain option' do
+    context 'when set' do
+      before do
+        Clearance.configuration.cookie_domain = '.example.com'
+        session.sign_in(user)
+      end
+
+      it 'sets a standard cookie' do
+        session.add_cookie_to_headers(headers)
+
+        headers['Set-Cookie'].should =~ /domain=\.example\.com; path/
+      end
+
+      after { restore_default_config }
+    end
+
+    context 'when not set' do
+      before { session.sign_in(user) }
+
+      it 'sets a standard cookie' do
+        session.add_cookie_to_headers(headers)
+
+        headers['Set-Cookie'].should_not =~ /domain=.+; path/
+      end
+    end
   end
 
-  context 'if secure_cookie is not set' do
-    before do
-      session.sign_in(user)
+  describe 'cookie path option' do
+    context 'when not set' do
+      before { session.sign_in(user) }
+
+      it 'sets a standard cookie' do
+        session.add_cookie_to_headers(headers)
+
+        headers['Set-Cookie'].should_not =~ /domain=.+; path/
+      end
     end
 
-    it 'sets a standard cookie' do
-      session.add_cookie_to_headers(headers)
+    context 'when set' do
+      before do
+        Clearance.configuration.cookie_path = '/user'
+        session.sign_in(user)
+      end
 
-      headers['Set-Cookie'].should_not =~ /remember_token=.+; secure/
+      it 'sets a standard cookie' do
+        session.add_cookie_to_headers(headers)
+
+        headers['Set-Cookie'].should =~ /path=\/user; expires/
+      end
+
+      after { restore_default_config }
     end
   end
 
@@ -164,8 +331,13 @@ describe Clearance::Session do
     header['Set-Cookie']
   end
 
+  def have_been_called
+    have_received(:call)
+  end
+
   def with_custom_expiration(custom_duration)
-    Clearance.configuration.cookie_expiration = lambda { custom_duration }
+    Clearance.configuration.cookie_expiration = custom_duration
+    yield
   ensure
     restore_default_config
   end

data/spec/clearance/sign_in_guard_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+module Clearance
+  describe SignInGuard do
+    it 'handles success' do
+      sign_in_guard = SignInGuard.new(stub('session'))
+      status = stub('status')
+      SuccessStatus.stubs(:new).returns(status)
+
+      expect(sign_in_guard.success).to eq(status)
+    end
+
+    it 'handles failure' do
+      sign_in_guard = SignInGuard.new(stub('session'))
+      status = stub('status')
+      failure_message = "Failed"
+      FailureStatus.stubs(:new).with(failure_message).returns(status)
+
+      expect(sign_in_guard.failure(failure_message)).to eq(status)
+    end
+
+    it 'can proceed to the next guard' do
+      guards = stub('guards', call: true)
+      sign_in_guard = SignInGuard.new(stub('session'), guards)
+      sign_in_guard.next_guard
+      expect(guards).to have_received(:call)
+    end
+  end
+end

data/spec/configuration_spec.rb

@@ -3,18 +3,18 @@ require 'spec_helper'
 describe Clearance::Configuration do
   after { restore_default_config }
 
-  describe 'when no user_model_name is specified' do
+  context 'when no user_model_name is specified' do
     before do
       Clearance.configure do |config|
       end
     end
 
     it 'defaults to User' do
-      Clearance.configuration.user_model.should == ::User
+      expect(Clearance.configuration.user_model).to eq ::User
     end
   end
 
-  describe 'when a custom user_model_name is specified' do
+  context 'when a custom user_model_name is specified' do
     before do
       MyUser = Class.new
 
@@ -23,53 +23,41 @@ describe Clearance::Configuration do
       end
     end
 
-    after do
-      Clearance.configure do |config|
-        config.user_model = ::User
-      end
-    end
-
     it 'is used instead of User' do
-      Clearance.configuration.user_model.should == ::MyUser
+      expect(Clearance.configuration.user_model).to eq ::MyUser
     end
   end
 
-  describe 'when secure_cookie is set to true' do
+  context 'when secure_cookie is set to true' do
     before do
       Clearance.configure do |config|
         config.secure_cookie = true
       end
     end
 
-    after do
-      Clearance.configure do |config|
-        config.secure_cookie = false
-      end
-    end
-
     it 'returns true' do
-      Clearance.configuration.secure_cookie.should be_true
+      expect(Clearance.configuration.secure_cookie).to be_true
     end
   end
 
-  describe 'when secure_cookie is not specified' do
+  context 'when secure_cookie is not specified' do
     before do
       Clearance.configure do |config|
       end
     end
 
     it 'defaults to false' do
-      Clearance.configuration.secure_cookie.should be_false
+      expect(Clearance.configuration.secure_cookie).to be_false
     end
   end
 
-  describe 'when no redirect URL specified' do
+  context 'when no redirect URL specified' do
     it 'should return "/" as redirect URL' do
-      Clearance::Configuration.new.redirect_url.should == '/'
+      expect(Clearance::Configuration.new.redirect_url).to eq '/'
     end
   end
 
-  describe 'when redirect URL is specified' do
+  context 'when redirect URL is specified' do
     let(:new_redirect_url) { '/admin' }
 
     before do
@@ -78,14 +66,50 @@ describe Clearance::Configuration do
       end
     end
 
-    after do
+    it 'should return new redirect URL' do
+      expect(Clearance.configuration.redirect_url).to eq new_redirect_url
+    end
+  end
+
+  context 'when specifying sign in guards' do
+    DummyGuard = Class.new
+
+    before do
       Clearance.configure do |config|
-        config.redirect_url = '/'
+        config.sign_in_guards = [DummyGuard]
       end
     end
 
-    it 'should return new redirect URL' do
-      Clearance.configuration.redirect_url.should == new_redirect_url
+    it 'should return the stack with added guards' do
+      expect(Clearance.configuration.sign_in_guards).to eq [DummyGuard]
+    end
+  end
+
+  context 'when cookie domain is specified' do
+    let(:domain) { '.example.com' }
+
+    before do
+      Clearance.configure do |config|
+        config.cookie_domain = domain
+      end
+    end
+
+    it 'returns configured value' do
+      expect(Clearance.configuration.cookie_domain).to eq domain
+    end
+  end
+
+  context 'when cookie path is specified' do
+    let(:path) { '/user' }
+
+    before do
+      Clearance.configure do |config|
+        config.cookie_path = path
+      end
+    end
+
+    it 'returns configured value' do
+      expect(Clearance.configuration.cookie_path).to eq path
     end
   end
 end