clearance 0.16.3 → 1.0.0.rc1

data/spec/models/sha1_spec.rb

@@ -3,41 +3,46 @@ require 'spec_helper'
 describe Clearance::PasswordStrategies::SHA1 do
   subject do
     Class.new do
-      attr_accessor :salt, :password, :encrypted_password
+      attr_accessor :salt, :encrypted_password
       include Clearance::PasswordStrategies::SHA1
 
       def generate_random_code; "code"; end
     end.new
   end
 
-  describe "#encrypt_password" do
-    context "when the password is set" do
-      let(:salt) { "salt" }
-      let(:password) { "password" }
+  describe '#password=' do
+    context 'when the password is set' do
+      let(:salt) { 'salt' }
+      let(:password) { 'password' }
 
       before do
         subject.salt = salt
         subject.password = password
-        subject.send(:encrypt_password)
       end
 
-      it "should encrypt the password using SHA1 into encrypted_password" do
-        expected = Digest::SHA1.hexdigest("--#{salt}--#{password}--")
+      it 'does not initialize the salt' do
+        subject.salt.should == salt
+      end
 
+      it 'encrypts the password using SHA1 and the existing salt' do
+        expected = Digest::SHA1.hexdigest("--#{salt}--#{password}--")
         subject.encrypted_password.should == expected
       end
     end
 
-    context "when the salt is not set" do
+    context "when the password is not set" do
       before do
-        subject.salt = nil
-
-        subject.send(:encrypt_password)
+        subject.salt     = nil
+        subject.password = ""
       end
 
-      it "should initialize the salt" do
+      it "initializes the salt" do
         subject.salt.should_not be_nil
       end
+
+      it "doesn't encrpt the password" do
+        subject.encrypted_password.should be_nil
+      end
     end
   end
 end

data/spec/models/user_spec.rb

@@ -4,129 +4,131 @@ describe User do
   it { should have_db_index(:email) }
   it { should have_db_index(:remember_token) }
 
-  describe "When signing up" do
+  describe 'when signing up' do
     it { should validate_presence_of(:email) }
     it { should validate_presence_of(:password) }
-    it { should allow_value("foo@example.co.uk").for(:email) }
-    it { should allow_value("foo@example.com").for(:email) }
-    it { should_not allow_value("foo@").for(:email) }
-    it { should_not allow_value("foo@example..com").for(:email) }
-    it { should_not allow_value("foo@.example.com").for(:email) }
-    it { should_not allow_value("foo").for(:email) }
-    it { should_not allow_value("example.com").for(:email) }
-
-    it "should store email in down case" do
-      user = create(:user, :email => "John.Doe@example.com")
-      user.email.should == "john.doe@example.com"
+    it { should allow_value('foo@example.co.uk').for(:email) }
+    it { should allow_value('foo@example.com').for(:email) }
+    it { should_not allow_value('foo@').for(:email) }
+    it { should_not allow_value('foo@example..com').for(:email) }
+    it { should_not allow_value('foo@.example.com').for(:email) }
+    it { should_not allow_value('foo').for(:email) }
+    it { should_not allow_value('example.com').for(:email) }
+
+    it 'stores email in down case' do
+      user = create(:user, :email => 'John.Doe@example.com')
+      user.email.should == 'john.doe@example.com'
     end
   end
 
-  describe "When multiple users have signed up" do
+  describe 'when multiple users have signed up' do
     before { create(:user) }
     it { should validate_uniqueness_of(:email) }
   end
 
-  describe "A user" do
+  describe 'a user' do
     before do
-      @user     = create(:user)
+      @user = create(:user)
       @password = @user.password
     end
 
-    it "is authenticated with correct email and password" do
-      (Clearance.configuration.user_model.authenticate(@user.email, @password)).should be
+    it 'is authenticated with correct email and password' do
+      (Clearance.configuration.user_model.authenticate(@user.email, @password)).
+        should be
       @user.should be_authenticated(@password)
     end
 
-    it "is authenticated with correct uppercased email and correct password" do
-      (Clearance.configuration.user_model.authenticate(@user.email.upcase, @password)).should be
+    it 'is authenticated with correct uppercased email and correct password' do
+      (Clearance.configuration.user_model.authenticate(@user.email.upcase, @password)).
+        should be
       @user.should be_authenticated(@password)
     end
 
-    it "is authenticated with incorrect credentials" do
-      (Clearance.configuration.user_model.authenticate(@user.email, 'bad_password')).should_not be
+    it 'is authenticated with incorrect credentials' do
+      (Clearance.configuration.user_model.authenticate(@user.email, 'bad_password')).
+        should_not be
       @user.should_not be_authenticated('bad password')
     end
   end
 
-  describe "When resetting authentication with reset_remember_token!" do
+  describe 'when resetting authentication with reset_remember_token!' do
     before do
       @user  = create(:user)
-      @user.remember_token = "old-token"
+      @user.remember_token = 'old-token'
       @user.reset_remember_token!
     end
 
-    it "should change the remember token" do
-      @user.remember_token.should_not == "old-token"
+    it 'changes the remember token' do
+      @user.remember_token.should_not == 'old-token'
     end
   end
 
-  describe "An email confirmed user" do
+  describe 'an email confirmed user' do
     before do
       @user = create(:user)
       @old_encrypted_password = @user.encrypted_password
     end
 
-    describe "who updates password" do
+    describe 'who updates password' do
       before do
-        @user.update_password("new_password")
+        @user.update_password('new_password')
       end
 
-      it "should change encrypted password" do
+      it 'changes encrypted password' do
         @user.encrypted_password.should_not == @old_encrypted_password
       end
     end
   end
 
-  it "should not generate the same remember token for users with the same password at the same time" do
-    Time.stubs(:now => Time.now)
-    password    = 'secret'
-    first_user  = create(:user, :password => password)
+  it 'does not generate same remember token for users with same password at same time' do
+    Time.stubs :now => Time.now
+    password = 'secret'
+    first_user = create(:user, :password => password)
     second_user = create(:user, :password => password)
-
     second_user.remember_token.should_not == first_user.remember_token
   end
 
-  describe "An user" do
+  describe 'a user' do
     before do
       @user = create(:user)
       @old_encrypted_password = @user.encrypted_password
     end
 
-    describe "who requests password reminder" do
+    describe 'who requests password reminder' do
       before do
         @user.confirmation_token.should be_nil
         @user.forgot_password!
       end
 
-      it "should generate confirmation token" do
+      it 'generates confirmation token' do
         @user.confirmation_token.should_not be_nil
       end
 
-      describe "and then updates password" do
+      describe 'and then updates password' do
         describe 'with password' do
           before do
-            @user.update_password("new_password")
+            @user.update_password 'new_password'
           end
 
-          it "should change encrypted password" do
+          it 'changes encrypted password' do
             @user.encrypted_password.should_not == @old_encrypted_password
           end
 
-          it "should clear confirmation token" do
+          it 'clears confirmation token' do
             @user.confirmation_token.should be_nil
           end
         end
 
         describe 'with blank password' do
           before do
-            @user.update_password("")
+            @user.update_password ''
           end
 
-          it "does not change encrypted password" do
+          it 'does not change encrypted password' do
             @user.encrypted_password.should == @old_encrypted_password
           end
 
-          it "does not clear confirmation token" do
+          it 'does not clear confirmation token' do
             @user.confirmation_token.should_not be_nil
           end
         end
@@ -134,7 +136,7 @@ describe User do
     end
   end
 
-  describe "a user with an optional email" do
+  describe 'a user with an optional email' do
     before do
       @user = User.new
       class << @user
@@ -147,12 +149,13 @@ describe User do
     subject { @user }
 
     it { should allow_value(nil).for(:email) }
-    it { should allow_value("").for(:email) }
+    it { should allow_value('').for(:email) }
   end
 
-  describe "a user with an optional password" do
+  describe 'a user with an optional password' do
     before do
       @user = User.new
+
       class << @user
         def password_optional?
           true
@@ -163,42 +166,24 @@ describe User do
     subject { @user }
 
     it { should allow_value(nil).for(:password) }
-    it { should allow_value("").for(:password) }
-  end
-
-  describe "user factory" do
-    it "should create a valid user with just an overridden password" do
-      build(:user, :password => "test").should be_valid
-    end
+    it { should allow_value('').for(:password) }
   end
 
-  describe "when user exists before Clearance was installed" do
-    before do
-      @user = create(:user)
-      sql  = "update users set salt = NULL, encrypted_password = NULL, remember_token = NULL where id = #{@user.id}"
-      ActiveRecord::Base.connection.update(sql)
-      @user.reload.salt.should be_nil
-      @user.reload.encrypted_password.should be_nil
-      @user.reload.remember_token.should be_nil
-    end
-
-    it "should initialize salt, generate remember token, and save encrypted password on update_password" do
-      @user.update_password('password')
-      @user.salt.should_not be_nil
-      @user.encrypted_password.should_not be_nil
-      @user.remember_token.should_not be_nil
+  describe 'user factory' do
+    it 'should create a valid user with just an overridden password' do
+      build(:user, :password => 'test').should be_valid
     end
   end
 
-  describe "The password setter on a User" do
-    let(:password) { "a-password" }
+  describe 'the password setter on a User' do
+    let(:password) { 'a-password' }
     before { subject.send(:password=, password) }
 
-    it "sets password to the plain-text password" do
+    it 'sets password to the plain-text password' do
       subject.password.should == password
     end
 
-    it "also sets encrypted_password" do
+    it 'also sets encrypted_password' do
       subject.encrypted_password.should_not be_nil
     end
   end

data/spec/spec_helper.rb

@@ -1,7 +1,7 @@
-ENV["RAILS_ENV"] ||= "test"
+ENV['RAILS_ENV'] ||= 'test'
 
-PROJECT_ROOT = File.expand_path("../..", __FILE__)
-$LOAD_PATH << File.join(PROJECT_ROOT, "lib")
+PROJECT_ROOT = File.expand_path('../..', __FILE__)
+$LOAD_PATH << File.join(PROJECT_ROOT, 'lib')
 
 require 'rails/all'
 require 'rails/test_help'
@@ -14,13 +14,12 @@ require 'bourne'
 require 'timecop'
 require 'factory_girl_rails'
 require 'shoulda-matchers'
-
 require 'clearance/testing'
 
-Dir[Rails.root.join("spec/support/**/*.rb")].each {|f| require f}
+Dir[Rails.root.join('spec/support/**/*.rb')].each {|f| require f}
 
 RSpec.configure do |config|
+  config.include FactoryGirl::Syntax::Methods
   config.mock_with :mocha
   config.use_transactional_fixtures = true
-  config.include FactoryGirl::Syntax::Methods
 end

data/spec/support/clearance.rb

@@ -25,10 +25,6 @@ module Clearance
       def redirect_to_url_after_destroy
         redirect_to(@controller.send(:url_after_destroy))
       end
-
-      def redirect_to_url_already_confirmed
-        redirect_to(@controller.send(:url_already_confirmed))
-      end
     end
   end
 end

data/spec/support/cookies.rb

@@ -1,21 +1,40 @@
 RSpec::Matchers.define :set_cookie do |name, expected_value, expected_expires_at|
+  failure_message_for_should do
+    "Expected #{expectation} got #{result}"
+  end
+
   match do |subject|
     @headers = subject
     @expected_name = name
     @expected_value = expected_value
     @expected_expires_at = expected_expires_at
-
     extract_cookies
     find_expected_cookie
     parse_expiration
     parse_value
     parse_path
-
     ensure_cookie_set
     ensure_expiration_correct
     ensure_path_is_correct
   end
 
+  def ensure_cookie_set
+    @value.should == @expected_value
+  end
+
+  def ensure_expiration_correct
+    @expires_at.should_not be_nil
+    @expires_at.should be_within(100).of(@expected_expires_at)
+  end
+
+  def ensure_path_is_correct
+    @path.should == "/"
+  end
+
+  def expectation
+    "a cookie named #{@expected_name} with value #{@expected_value.inspect} expiring at #{@expected_expires_at.inspect}"
+  end
+
   def extract_cookies
     @cookie_headers = @headers['Set-Cookie'] || []
     @cookie_headers = [@cookie_headers] if @cookie_headers.respond_to?(:to_str)
@@ -33,37 +52,16 @@ RSpec::Matchers.define :set_cookie do |name, expected_value, expected_expires_at
     end
   end
 
-  def parse_value
-    if @cookie && result = @cookie.match(/=(.*?)(?:;|$)/)
-      @value = result[1]
-    end
-  end
-
   def parse_path
     if @cookie && result = @cookie.match(/; path=(.*?)(;|$)/)
       @path = result[1]
     end
   end
 
-  def ensure_cookie_set
-    @value.should == @expected_value
-  end
-
-  def ensure_expiration_correct
-    @expires_at.should_not be_nil
-    @expires_at.should be_within(100).of(@expected_expires_at)
-  end
-
-  def ensure_path_is_correct
-    @path.should == "/"
-  end
-
-  failure_message_for_should do
-    "Expected #{expectation} got #{result}"
-  end
-
-  def expectation
-    "a cookie named #{@expected_name} with value #{@expected_value.inspect} expiring at #{@expected_expires_at.inspect}"
+  def parse_value
+    if @cookie && result = @cookie.match(/=(.*?)(?:;|$)/)
+      @value = result[1]
+    end
   end
 
   def result

data/spec/support/request_with_remember_token.rb

@@ -0,0 +1,19 @@
+module RememberTokenHelpers
+  def request_with_remember_token(remember_token)
+    cookies = {
+      'action_dispatch.cookies' => {
+        Clearance::Session::REMEMBER_TOKEN_COOKIE => remember_token
+      }
+    }
+    env = { :clearance => Clearance::Session.new(cookies) }
+    Rack::Request.new env
+  end
+
+  def request_without_remember_token
+    request_with_remember_token nil
+  end
+end
+
+RSpec.configure do |config|
+  config.include RememberTokenHelpers
+end