clearance 0.16.3 → 1.0.0.rc1

data/spec/clearance/constraints/signed_in_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe Clearance::Constraints::SignedIn do
+  it 'returns true when user is signed in' do
+    user = create(:user)
+    signed_in_constraint = Clearance::Constraints::SignedIn.new
+    signed_in_constraint.matches?(request_with_remember_token(user.remember_token)).
+      should be_true
+  end
+
+  it 'returns false when user is not signed in' do
+    signed_in_constraint = Clearance::Constraints::SignedIn.new
+    signed_in_constraint.matches?(request_without_remember_token).should be_false
+  end
+
+  it 'yields a signed-in user to a provided block' do
+    user = create(:user, :email => 'before@example.com')
+
+    signed_in_constraint = Clearance::Constraints::SignedIn.new do |user|
+      user.update_attribute :email, 'after@example.com'
+    end
+
+    signed_in_constraint.matches?(request_with_remember_token(user.remember_token))
+    user.reload.email.should == 'after@example.com'
+  end
+
+  it 'does not yield a user if they are not signed in' do
+    user = create(:user, :email => 'before@example.com')
+
+    signed_in_constraint = Clearance::Constraints::SignedIn.new do |user|
+      user.update_attribute :email, 'after@example.com'
+    end
+
+    signed_in_constraint.matches?(request_without_remember_token)
+    user.reload.email.should == 'before@example.com'
+  end
+
+  it 'matches if the user-provided block returns true' do
+    user = create(:user)
+    signed_in_constraint = Clearance::Constraints::SignedIn.new { |user| true }
+    signed_in_constraint.matches?(request_with_remember_token(user.remember_token)).
+      should be_true
+  end
+
+  it 'does not match if the user-provided block returns false' do
+    user = create(:user)
+    signed_in_constraint = Clearance::Constraints::SignedIn.new { |user| false }
+    signed_in_constraint.matches?(request_with_remember_token(user.remember_token)).
+      should be_false
+  end
+end

data/spec/clearance/constraints/signed_out_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+describe Clearance::Constraints::SignedOut do
+  it 'returns true when user is signed out' do
+    signed_out_constraint = Clearance::Constraints::SignedOut.new
+    signed_out_constraint.matches?(request_without_remember_token).should be_true
+  end
+
+  it 'returns false when user is not signed out' do
+    user = create(:user)
+    signed_out_constraint = Clearance::Constraints::SignedOut.new
+    signed_out_constraint.matches?(request_with_remember_token(user.remember_token)).
+      should be_false
+  end
+end

data/spec/clearance/rack_session_spec.rb

@@ -1,23 +1,24 @@
 require 'spec_helper'
 
 describe Clearance::RackSession do
-  it "injects a clearance session into the environment" do
-    expected_session = "the session"
-    expected_session.stubs(:add_cookie_to_headers)
-    Clearance::Session.stubs(:new => expected_session)
-    headers = { "X-Roaring-Lobster" => "Red" }
+  it 'injects a clearance session into the environment' do
+    expected_session = 'the session'
+    expected_session.stubs :add_cookie_to_headers
+    Clearance::Session.stubs :new => expected_session
+    headers = { 'X-Roaring-Lobster' => 'Red' }
 
     app = Rack::Builder.new do
       use Clearance::RackSession
       run lambda { |env| Rack::Response.new(env[:clearance], 200, headers).finish }
     end
 
-    env = Rack::MockRequest.env_for("/")
+    env = Rack::MockRequest.env_for('/')
 
     response = Rack::MockResponse.new(*app.call(env))
 
     Clearance::Session.should have_received(:new).with(env)
     response.body.should == expected_session
-    expected_session.should have_received(:add_cookie_to_headers).with(has_entries(headers))
+    expected_session.should have_received(:add_cookie_to_headers).
+      with(has_entries(headers))
   end
 end

data/spec/clearance/session_spec.rb

@@ -4,95 +4,101 @@ describe Clearance::Session do
   before { Timecop.freeze }
   after { Timecop.return }
 
-  it "finds a user from a cookie" do
+  it 'finds a user from a cookie' do
     user = create(:user)
     env = env_with_remember_token(user.remember_token)
-
     session = Clearance::Session.new(env)
     session.should be_signed_in
     session.current_user.should == user
   end
 
-  it "returns nil for an unknown user" do
+  it 'returns nil for an unknown user' do
     user = create(:user)
-    env = env_with_remember_token("bogus")
-
+    env = env_with_remember_token('bogus')
     session = Clearance::Session.new(env)
-    session.should_not be_signed_in
+    session.should be_signed_out
     session.current_user.should be_nil
   end
 
-  it "returns nil without a remember token" do
+  it 'returns nil without a remember token' do
     env = env_without_remember_token
     session = Clearance::Session.new(env)
-    session.should_not be_signed_in
+    session.should be_signed_out
     session.current_user.should be_nil
   end
 
-  it "signs in a given user" do
+  it 'signs in a given user' do
     user = create(:user)
     session = Clearance::Session.new(env_without_remember_token)
     session.sign_in user
     session.current_user.should == user
   end
 
-  it "sets a remember token cookie with a default expiration of 1 year from now" do
+  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)
+    headers.should set_cookie('remember_token', user.remember_token, 1.year.from_now)
   end
 
-  it "sets a remember token cookie with a custom expiration" do
+  it 'sets a remember token cookie with a custom expiration' do
     custom_expiration = 1.day.from_now
+
     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)
+      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)
     end
   end
 
-  it "doesn't set a remember token when signed out" do
+  it 'does not set a remember token when signed out' do
     headers = {}
     session = Clearance::Session.new(env_without_remember_token)
     session.add_cookie_to_headers headers
-    headers.should_not set_cookie("remember_token")
+    headers.should_not set_cookie('remember_token')
   end
 
-  it "signs out a user" do
+  it 'signs out a user' do
     user = create(:user)
     old_remember_token = user.remember_token
     env = env_with_remember_token(old_remember_token)
-
     session = Clearance::Session.new(env)
     session.sign_out
     session.current_user.should be_nil
     user.reload.remember_token.should_not == old_remember_token
   end
 
+  def env_with_cookies(cookies)
+    Rack::MockRequest.env_for '/', 'HTTP_COOKIE' => serialize_cookies(cookies)
+  end
+
   def env_with_remember_token(token)
-    env_with_cookies("remember_token" => token)
+    env_with_cookies 'remember_token' => token
   end
 
   def env_without_remember_token
     env_with_cookies({})
   end
 
-  def env_with_cookies(cookies)
-    Rack::MockRequest.env_for("/", "HTTP_COOKIE" => serialize_cookies(cookies))
+  def restore_default_config
+    Clearance.configuration = nil
+    Clearance.configure {}
   end
 
   def serialize_cookies(hash)
     header = {}
+
     hash.each do |key, value|
-      Rack::Utils.set_cookie_header!(header, key, value)
+      Rack::Utils.set_cookie_header! header, key, value
     end
+
     header['Set-Cookie']
   end
 
@@ -101,9 +107,4 @@ describe Clearance::Session do
   ensure
     restore_default_config
   end
-
-  def restore_default_config
-    Clearance.configuration = nil
-    Clearance.configure {}
-  end
 end

data/spec/configuration_spec.rb

@@ -1,20 +1,21 @@
 require 'spec_helper'
 
 describe Clearance::Configuration do
-  describe "when no user_model_name is specified" do
+  describe 'when no user_model_name is specified' do
     before do
       Clearance.configure do |config|
       end
     end
 
-    it "defaults to User" do
+    it 'defaults to User' do
       Clearance.configuration.user_model.should == ::User
     end
   end
 
-  describe "when a custom user_model_name is specified" do
+  describe 'when a custom user_model_name is specified' do
     before do
       MyUser = Class.new
+
       Clearance.configure do |config|
         config.user_model = MyUser
       end
@@ -26,8 +27,8 @@ describe Clearance::Configuration do
       end
     end
 
-    it "is used instead of User" do
+    it 'is used instead of User' do
       Clearance.configuration.user_model.should == ::MyUser
     end
-  end 
-end
+  end
+end

data/spec/controllers/denies_controller_spec.rb

@@ -5,17 +5,17 @@ class DeniesController < ActionController::Base
   before_filter :authorize, :only => :show
 
   def new
-    render :text => "New page"
+    render :text => 'New page'
   end
 
   def show
-    render :text => "Show page"
+    render :text => 'Show page'
   end
 
   protected
 
   def authorize
-    deny_access("Access denied.")
+    deny_access 'Access denied.'
   end
 end
 
@@ -31,30 +31,31 @@ describe DeniesController do
     Rails.application.reload_routes!
   end
 
-  context "signed in user" do
+  context 'signed in user' do
     before { sign_in }
 
-    it "allows access to new" do
+    it 'allows access to new' do
       get :new
       subject.should_not deny_access
     end
 
-    it "denies access to show" do
+    it 'denies access to show' do
       get :show
       subject.should deny_access(:redirect => '/')
     end
   end
 
-  context "visitor" do
-    it "allows access to new" do
+  context 'visitor' do
+    it 'allows access to new' do
       get :new
       subject.should_not deny_access
     end
 
-    it "denies access to show" do
+    it 'denies access to show' do
       get :show
       subject.should deny_access
-      subject.should deny_access(:redirect => sign_in_url, :flash => "Access denied.")
+      subject.should deny_access(:redirect => sign_in_url,
+        :flash => 'Access denied.')
     end
   end
 end

data/spec/controllers/flashes_controller_spec.rb

@@ -16,8 +16,8 @@ end
 describe FlashesController do
   before do
     Rails.application.routes.draw do
-      match "set_flash" => "flashes#set_flash"
-      match "view_flash" => "flashes#view_flash"
+      match 'set_flash' => 'flashes#set_flash'
+      match 'view_flash' => 'flashes#view_flash'
     end
   end
 
@@ -25,8 +25,8 @@ describe FlashesController do
     Rails.application.reload_routes!
   end
 
-  it "sets and views a flash" do
-    visit "/set_flash?message=hello"
-    page.should have_content("hello")
+  it 'sets and views a flash' do
+    visit '/set_flash?message=hello'
+    page.should have_content('hello')
   end
 end

data/spec/controllers/forgeries_controller_spec.rb

@@ -14,7 +14,7 @@ class ForgeriesController < ActionController::Base
 end
 
 describe ForgeriesController do
-  context "signed in user" do
+  context 'signed in user' do
     before do
       Rails.application.routes.draw do
         resources :forgeries
@@ -22,26 +22,26 @@ describe ForgeriesController do
       end
 
       @user = create(:user)
-      @user.update_attribute(:remember_token, "old-token")
-      @request.cookies["remember_token"] = "old-token"
-      @request.session[:_csrf_token] = "golden-ticket"
+      @user.update_attribute(:remember_token, 'old-token')
+      @request.cookies['remember_token'] = 'old-token'
+      @request.session[:_csrf_token] = 'golden-ticket'
     end
 
     after do
       Rails.application.reload_routes!
     end
 
-    it "succeeds with authentic token" do
-      post :create, :authenticity_token => "golden-ticket"
+    it 'succeeds with authentic token' do
+      post :create, :authenticity_token => 'golden-ticket'
       subject.should redirect_to(:action => 'index')
     end
 
-    it "fails with invalid token" do
-      post :create, :authenticity_token => "hax0r"
+    it 'fails with invalid token' do
+      post :create, :authenticity_token => 'hax0r'
       subject.should deny_access
     end
 
-    it "fails with no token" do
+    it 'fails with no token' do
       post :create
       subject.should deny_access
     end

data/spec/controllers/passwords_controller_spec.rb

@@ -3,40 +3,41 @@ require 'spec_helper'
 describe Clearance::PasswordsController do
   include Shoulda::Matchers::ActionMailer
 
-  it { should route(:get, '/users/1/password/edit').
-                to(:controller => 'clearance/passwords', :action  => 'edit', :user_id => '1') }
+  it {
+   should route(:get, '/users/1/password/edit').
+     to(:controller => 'clearance/passwords', :action  => 'edit', :user_id => '1')
+  }
 
-  describe "a signed up user" do
+  describe 'a signed up user' do
     before do
       @user = create(:user)
     end
 
-    describe "on GET to #new" do
+    describe 'on GET to #new' do
       before { get :new, :user_id => @user.to_param }
 
       it { should respond_with(:success) }
       it { should render_template(:new) }
     end
 
-    describe "on POST to #create" do
-      describe "with correct email address" do
+    describe 'on POST to #create' do
+      describe 'with correct email address' do
         before do
           ActionMailer::Base.deliveries.clear
           post :create, :password => { :email => @user.email }
         end
 
-        it "should generate a token for the change your password email" do
+        it 'should generate a token for the change your password email' do
           @user.reload.confirmation_token.should_not be_nil
         end
 
         it { should have_sent_email.with_subject(/change your password/i) }
-
         it { should respond_with(:success) }
       end
 
-      describe "with incorrect email address" do
+      describe 'with incorrect email address' do
         before do
-          email = "user1@example.com"
+          email = 'user1@example.com'
           (Clearance.configuration.user_model.exists?(['email = ?', email])).should_not be
           ActionMailer::Base.deliveries.clear
           @user.reload.confirmation_token.should == @user.confirmation_token
@@ -44,11 +45,11 @@ describe Clearance::PasswordsController do
           post :create, :password => { :email => email }
         end
 
-        it "should not generate a token for the change your password email" do
+        it 'should not generate a token for the change your password email' do
           @user.reload.confirmation_token.should == @user.confirmation_token
         end
 
-        it "should not send a password reminder email" do
+        it 'should not send a password reminder email' do
           ActionMailer::Base.deliveries.should be_empty
         end
 
@@ -58,19 +59,19 @@ describe Clearance::PasswordsController do
     end
   end
 
-  describe "a signed up user and forgotten password" do
+  describe 'a signed up user and forgotten password' do
     before do
       @user = create(:user)
       @user.forgot_password!
     end
 
-    describe "on GET to #edit with correct id and token" do
+    describe 'on GET to #edit with correct id and token' do
       before do
         get :edit, :user_id => @user.to_param,
-                   :token   => @user.confirmation_token
+          :token => @user.confirmation_token
       end
 
-      it "should find the user" do
+      it 'should find the user' do
         assigns(:user).should == @user
       end
 
@@ -78,16 +79,16 @@ describe Clearance::PasswordsController do
       it { should render_template(:edit) }
     end
 
-    describe "on GET to #edit with correct id but blank token" do
+    describe 'on GET to #edit with correct id but blank token' do
       before do
-        get :edit, :user_id => @user.to_param, :token => ""
+        get :edit, :user_id => @user.to_param, :token => ''
       end
 
       it { should set_the_flash.to(/double check the URL/i).now }
       it { should render_template(:new) }
     end
 
-    describe "on GET to #edit with correct id but no token" do
+    describe 'on GET to #edit with correct id but no token' do
       before do
         get :edit, :user_id => @user.to_param
       end
@@ -96,56 +97,46 @@ describe Clearance::PasswordsController do
       it { should render_template(:new) }
     end
 
-    describe "on PUT to #update with password" do
+    describe 'on PUT to #update with password' do
       before do
-        new_password = "new_password"
-        @encrypted_new_password = @user.send(:encrypt, new_password)
-        @user.encrypted_password.should_not == @encrypted_new_password
-
-        put(:update,
-            :user_id => @user,
-            :token   => @user.confirmation_token,
-            :user    => {
-              :password => new_password
-            })
+        @new_password = 'new_password'
+        @user.encrypted_password.should_not == @new_password
+        put :update, :user_id => @user, :token => @user.confirmation_token,
+          :user => { :password => @new_password }
         @user.reload
       end
 
-      it "should update password" do
-        @user.encrypted_password.should == @encrypted_new_password
+      it 'should update password' do
+        @user.encrypted_password.should == @new_password
       end
 
-      it "should clear confirmation token" do
+      it 'should clear confirmation token' do
         @user.confirmation_token.should be_nil
       end
 
-      it "should set remember token" do
+      it 'should set remember token' do
         @user.remember_token.should_not be_nil
       end
 
       it { should redirect_to_url_after_update }
     end
 
-    describe "on PUT to #update with blank password" do
+    describe 'on PUT to #update with blank password' do
       before do
-        put(:update,
-            :user_id => @user.to_param,
-            :token   => @user.confirmation_token,
-            :user    => {
-              :password => ''
-            })
+        put :update, :user_id => @user.to_param, :token => @user.confirmation_token,
+          :user => { :password => '' }
         @user.reload
       end
 
-      it "should not update password" do
-        @user.encrypted_password.should_not == @encrypted_new_password
+      it 'should not update password to be blank' do
+        @user.encrypted_password.should_not be_blank
       end
 
-      it "should not clear token" do
+      it 'should not clear token' do
         @user.confirmation_token.should_not be_nil
       end
 
-      it "should not be signed in" do
+      it 'should not be signed in' do
         cookies[:remember_token].should be_nil
       end
 
@@ -154,16 +145,12 @@ describe Clearance::PasswordsController do
       it { should render_template(:edit) }
     end
 
-    describe "on PUT to #update with an empty token after the user sets a password" do
+    describe 'on PUT to #update with an empty token after the user sets a password' do
       before do
-        put :update,
-            :user_id => @user.to_param,
-            :token   => @user.confirmation_token,
-            :user    => { :password => 'good password' }
-        put :update,
-            :user_id => @user.to_param,
-            :token   => [nil],
-            :user    => { :password => 'new password' }
+        put :update, :user_id => @user.to_param, :token => @user.confirmation_token,
+          :user => { :password => 'good password' }
+        put :update, :user_id => @user.to_param, :token => [nil],
+          :user => { :password => 'new password' }
       end
 
       it { should set_the_flash.to(/double check the URL/i).now }
@@ -171,7 +158,7 @@ describe Clearance::PasswordsController do
     end
   end
 
-  describe "given two users and user one signs in" do
+  describe 'given two users and user one signs in' do
     before do
       @user_one = create(:user)
       @user_two = create(:user)