remarkable_devise 1.0.0.alpha3 → 1.0.0

data/remarkable_devise.gemspec

@@ -21,7 +21,7 @@ Gem::Specification.new do |s|
   s.add_runtime_dependency(%q<rspec>, [">=2.1.0"])
   s.add_runtime_dependency(%q<rails>, [">=3.0.1"])
   s.add_runtime_dependency(%q<activerecord>, [">=3.0.1"])
-  s.add_runtime_dependency(%q<remarkable_activerecord>, ["4.0.0.alpha4"])
+  s.add_runtime_dependency(%q<remarkable_activerecord>, [">=4.0.0.alpha4"])
   s.add_runtime_dependency(%q<devise>, [">=1.1.3"])
 
   s.add_development_dependency "mocha"

data/spec/example_models.rb

@@ -1,6 +1,14 @@
 class User < ActiveRecord::Base
-  devise :database_authenticatable, :confirmable, :recoverable,
-  :rememberable, :trackable, :validatable, :token_authenticatable
+  devise :database_authenticatable, :stretches => 15, :encryptor => :clearance_sha1, :authentication_keys => [:email, :login], :params_authenticatable => false
+  devise :confirmable, :confirm_within => 2.days
+  devise :recoverable
+  devise :rememberable, :remember_for => 2.weeks, :extend_remember_period => true, :cookie_domain => 'foo'
+  devise :trackable
+  devise :validatable, :password_length => 8..20, :email_regexp => /^([\w\.%\+\-]+)@([\w\-]+\.)+([\w]{2,})$/i
+  devise :token_authenticatable, :token_authentication_key => :auth_token
+  devise :timeoutable, :timeout_in => 15.minutes
+  devise :lockable, :maximum_attempts => 10, :lock_strategy => :none, :unlock_strategy => :time, :unlock_in => 5.hours
+  devise :registerable
 end
 
 class FooUser < ActiveRecord::Base

data/spec/examples/user_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+describe User do
+  before do
+    User.stubs(:column_names).returns(%w{email encrypted_password password_salt confirmation_token confirmed_at confirmation_sent_at remember_token remember_created_at locked_at authentication_token sign_in_count current_sign_in_at last_sign_in_at current_sign_in_ip last_sign_in_ip reset_password_token failed_attempts unlock_token})
+  end
+    
+  it { should be_a_confirmable(:confirm_within => 2.days) }
+  it { should be_a_rememberable(:remember_for => 2.weeks) }
+  it { should be_a_validatable(:password_length => 8..20) }
+  it { should be_a_timeoutable(:timeout_in => 15.minutes) }
+  it { should be_a_lockable(:lock_strategy => :failed_attempts, :unlock_strategy => :both) }
+  it { should be_a_token_authenticatable }
+  it { should be_a_trackable }
+  it { should be_a_registerable }
+  it { should be_a_recoverable }
+  
+  should_be_a_database_authenticatable do |o|
+    o.stretches = 15
+    o.encryptor = :clearance_sha1
+    o.params_authenticatable = false
+    o.authentication_keys = [:email, :login]
+  end
+end

data/spec/matchers/be_a_confirmable_spec.rb

@@ -17,6 +17,18 @@ describe Remarkable::Devise::Matchers::BeAConfirmableMatcher do
     end
   end
 
+  context "options validation" do
+    describe :confirm_within do
+      it "should validate that model has proper :confirm_within" do
+        subject.class.new(:confirm_within => 2.days).matches?(User).should be_true
+      end
+
+      it "should validate that model hasn't proper :confirm_within" do
+        subject.class.new(:confirm_within => 3.days).matches?(User).should be_false
+      end
+    end
+  end
+
   context "columns validation" do
     context "confirmation_token column" do
       before do
@@ -71,11 +83,18 @@ describe Remarkable::Devise::Matchers::BeAConfirmableMatcher do
   end
 
   describe "description" do
-    before do
-      @msg = subject.description
+    context "when matching without options" do
+      specify { subject.description.should eql('be a confirmable') }
+    end
+
+    context "when matching with :confirm_within" do
+      before do
+        @matcher = subject.class.new(:confirm_within => 5.days)
+        @matcher.matches?(User)
+      end
+
+      specify { @matcher.description.should eql("be a confirmable within 5 days") }
     end
-    
-    specify { @msg.should eql('be a confirmable') }
   end
 
   context "expectation message" do
@@ -121,5 +140,14 @@ describe Remarkable::Devise::Matchers::BeAConfirmableMatcher do
 
       specify { @msg.should match('to have confirmation_sent_at column') }
     end
+
+    context "when :confirm_within doesn't match" do
+      before do
+        @matcher = subject.class.new(:confirm_within => 3.days)
+        @matcher.matches?(User)
+      end
+
+      specify { @matcher.failure_message_for_should.should match("User to be a confirmable with options (.+), got (.+)")}
+    end
   end
 end

data/spec/matchers/be_a_database_authenticatable_spec.rb

@@ -1,6 +1,8 @@
 require 'spec_helper'
 
 describe Remarkable::Devise::Matchers::BeADatabaseAuthenticatableMatcher do
+  it_should_behave_like "any Devise authentication model"
+  
   before do
     @valid_columns = ['email', 'encrypted_password', 'password_salt']
 
@@ -13,7 +15,29 @@ describe Remarkable::Devise::Matchers::BeADatabaseAuthenticatableMatcher do
     end
 
     it "should validate that model has no :database_authenticatable model" do
-       subject.matches?(FooUser).should be_false
+      subject.matches?(FooUser).should be_false
+    end
+  end
+
+  context "options validation" do
+    describe :stretches do
+      it "should validate that a model has proper :stratches" do
+        subject.class.new(:stretches => 15).matches?(User).should be_true
+      end
+
+      it "should validate that a model hasn't proper :stratches" do
+        subject.class.new(:stretches => 10).matches?(User).should be_false
+      end
+    end
+
+    describe :encryptor do
+      it "should validate that a model has proper :encryptor" do
+        subject.class.new(:encryptor => :clearance_sha1).matches?(User).should be_true
+      end
+
+      it "should validate that a model hasn't proper :encryptor" do
+        subject.class.new(:encryptor => :bcrypt).matches?(User).should be_false
+      end
     end
   end
   
@@ -71,16 +95,33 @@ describe Remarkable::Devise::Matchers::BeADatabaseAuthenticatableMatcher do
   end
 
   describe "description" do
-    before do
-      @msg = subject.description
+    context "when matching without options" do
+      specify { subject.description.should eql('be a database authenticatable') }
+    end
+
+    context "when matching with :stretches option" do
+      before do
+        @matcher = subject.class.new(:stretches => 15)
+        @matcher.matches?(User)
+      end
+
+      specify { @matcher.description.should eql("be a database authenticatable with password stretches 15") }
+    end
+
+    context "when matching with :encryptor option" do
+      before do
+        @matcher = subject.class.new(:encryptor => :bcrypt)
+        @matcher.matches?(User)
+      end
+
+      specify { @matcher.description.should eql("be a database authenticatable with :bcrypt password encryptor") }
     end
-    
-    specify { @msg.should eql('be a database authenticatable') }
   end
 
   context "expectation message" do
     context "when Devise::Models::DatabaseAuthenticatable not included" do
       before do
+        subject.stubs(:has_authenticatable_module_included?).returns(true)
         subject.matches?(FooUser)
         
         @msg = subject.failure_message_for_should
@@ -121,5 +162,14 @@ describe Remarkable::Devise::Matchers::BeADatabaseAuthenticatableMatcher do
 
       specify { @msg.should match('to have password_salt column') }
     end
+
+    context "when options doesn't match" do
+      before do
+        @matcher = subject.class.new(:stretches => 10)
+        @matcher.matches?(User)
+      end
+
+      specify { @matcher.failure_message_for_should.should match('User to be a database authenticatable with options (.+), got (.+)') }
+    end
   end
 end

data/spec/matchers/be_a_lockable_spec.rb

@@ -0,0 +1,274 @@
+require 'spec_helper'
+
+describe Remarkable::Devise::Matchers::BeALockableMatcher do
+  before do
+    @valid_columns = %w{failed_attempts unlock_token locked_at}
+
+    User.stubs(:column_names).returns(@valid_columns)
+  end
+
+  describe "validation of Devise::Models::Lockable module inclusion" do
+    before do
+      User.stubs(:lock_strategy).returns(:none)
+      User.stubs(:unlock_strategy).returns(:none)
+      User.stubs(:has_column?).returns(true)
+    end
+
+    it "should validate that a model has Devise::Models::Lockable module included" do
+      subject.matches?(User).should be_true
+    end
+
+    it "should validate that a model hasn't Devise::Models::Lockable module included" do
+      subject.matches?(FooUser).should be_false
+    end
+  end
+
+  describe "columns validation" do
+    before do
+      subject.stubs(:included?).returns(true)
+    end
+
+    context "when :lock_strategy is :failed_attempts" do
+      before do
+        User.stubs(:lock_strategy).returns(:failed_attempts)
+      end
+
+      it "should validate that a model has :failed_attempts column" do
+        subject.matches?(User).should be_true
+      end
+
+      it "should validate that a model hasn't :faild_attempts column" do
+        User.stubs(:column_names).returns(@valid_columns - ['failed_attempts'])
+        
+        subject.matches?(User).should be_false
+      end
+    end
+
+    context "when :lock_strategy is :none" do
+      before do
+        User.stubs(:lock_strategy).returns(:none)
+      end
+
+      context "when a model has :failed_attempts column" do
+        it "should match" do
+          subject.matches?(User).should be_true
+        end
+      end
+
+      context "when a model hasn't :failed_attempts column" do
+        before do
+          User.stubs(:column_names).returns(@valid_columns - ['failed_attempts'])
+        end
+
+        it "should match" do
+          subject.matches?(User).should be_true
+        end
+      end
+    end
+
+    context "when :unlock_strategy is :time" do
+      before do
+         User.stubs(:unlock_strategy).returns(:time)
+      end
+
+      it_should_behave_like "lockable matcher for unlock_strategy without unlock_token column needed"
+    end
+
+    context "when :unlock_strategy is :email" do
+      before do
+        User.stubs(:unlock_strategy).returns(:email)
+      end
+
+      it_should_behave_like "lockable matcher for unlock_strategy with unlock_token column needed"
+    end
+
+    context "when :unlock_strategy is :both" do
+      before do
+        User.stubs(:unlock_strategy).returns(:both)
+      end
+
+      it_should_behave_like "lockable matcher for unlock_strategy with unlock_token column needed"
+    end
+
+    context "when :unlock_strategy is :none" do
+      before do
+        User.stubs(:unlock_strategy).returns(:none)
+      end
+
+      it_should_behave_like "lockable matcher for unlock_strategy without unlock_token column needed"
+    end
+
+    describe :locked_at do
+      context "when a model has locked_at column" do
+        it "should match" do
+          subject.matches?(User).should be_true
+        end
+      end
+
+      context "when a model has no locked_at column" do
+        before do
+          User.stubs(:column_names).returns(@valid_columns - ['locked_at'])
+        end
+
+        it "should not match" do
+          subject.matches?(User).should be_false
+        end
+      end
+    end
+  end
+
+  describe "matching with options" do
+    describe :maximum_attempts do
+      context "when a model has expected :maximum_attepmts value" do
+        it "should match" do
+          subject.class.new(:maximum_attempts => 10).matches?(User).should be_true
+        end
+      end
+
+      context "when a model hasn't expected :maximum_attempts value" do
+        it "should not match" do
+          subject.class.new(:maximum_attempts => 25).matches?(User).should be_false
+        end
+      end
+    end
+
+    describe :lock_strategy do
+      context "when a model has expected :lock_strategy value" do
+        it "should match" do
+          subject.class.new(:lock_strategy => :none).matches?(User).should be_true
+        end
+      end
+
+      context "when a model hasn't expected :lock_strategy value" do
+        it "should not match" do
+          subject.class.new(:lock_strategy => :failed_attempts).matches?(User).should be_false
+        end
+      end
+    end
+
+    describe :unlock_strategy do
+      context "when a model has expected :unlock_strategy value" do
+        it "should match" do
+          subject.class.new(:unlock_strategy => :time).matches?(User).should be_true
+        end
+      end
+
+      context "when a model hasn't expected :unlock_strategy value" do
+        it "should not match" do
+          subject.class.new(:unlock_strategy => :both).matches?(User).should be_false
+        end
+      end
+    end
+
+    describe :unlock_in do
+      context "when a model has expected :unlock_in value" do
+        it "should match" do
+          subject.class.new(:unlock_in => 5.hours).matches?(User).should be_true
+        end
+
+      end
+
+      context "when a model hasn't expected :unlock_in value" do
+        it "should not match" do
+          subject.class.new(:unlock_in => 1.hour).matches?(User).should be_false
+        end
+      end
+    end
+  end
+
+  describe "description" do
+    context "when matching without options" do
+      specify { subject.description.should eql('be a lockable') }
+    end
+
+    context "when matching with :maximum_attempts option" do
+      before do
+        @matcher = subject.class.new(:maximum_attempts => 10)
+        @matcher.matches?(User)
+      end
+
+      specify { @matcher.description.should eql("be a lockable with 10 maximum attempts") }
+    end
+
+    context "when matching with :lock_strategy option" do
+      before do
+        @matcher = subject.class.new(:lock_strategy => :time)
+        @matcher.matches?(User)
+      end
+
+      specify { @matcher.description.should eql("be a lockable with :time lock strategy") }
+    end
+
+    context "when matching with :unlock_strategy option" do
+      before do
+        @matcher = subject.class.new(:unlock_strategy => :both)
+        @matcher.matches?(User)
+      end
+
+      specify { @matcher.description.should eql("be a lockable with :both unlock strategy") }
+    end
+
+    context "when matching with :unlock_in option" do
+      before do
+        @matcher = subject.class.new(:unlock_in => 5.minutes)
+        @matcher.matches?(User)
+      end
+
+      specify { @matcher.description.should eql("be a lockable with unlock in 300 seconds") }
+    end
+  end
+
+  describe "failure message" do
+    before do
+      User.lock_strategy = :failed_attempts
+      User.unlock_strategy = :both
+    end
+
+    context "when module Devise::Models::Lockable is not included" do
+      before do
+        subject.matches?(FooUser)
+      end
+
+      specify { subject.failure_message_for_should.should match("Foo user to have Devise :lockable model") }
+    end
+
+    context "when model doesn't have :failed_attempts column" do
+      before do
+        User.stubs(:column_names).returns(@valid_columns - ['failed_attempts'])
+
+        subject.matches?(User)
+      end
+
+      specify { subject.failure_message_for_should.should match("User to have failed_attempts column") }
+    end
+
+    context "when model doesn't have :unlock_token column" do
+      before do
+        User.stubs(:column_names).returns(@valid_columns - ['unlock_token'])
+
+        subject.matches?(User)
+      end
+
+      specify { subject.failure_message_for_should.should match("User to have unlock_token column") }
+    end
+
+    context "when model doesn't have :locked_at column" do
+      before do
+        User.stubs(:column_names).returns(@valid_columns - ['locked_at'])
+
+        subject.matches?(User)
+      end
+
+      specify { subject.failure_message_for_should.should match("User to have locked_at column") }
+    end
+
+    context "when options doesn't match" do
+      before do
+        @matcher = subject.class.new(:maximum_attempts => 15)
+        @matcher.matches?(User)
+      end
+
+      specify { @matcher.failure_message_for_should.should match("User to be a lockable with options (.+), got (.+)") }
+    end
+  end
+end