remarkable_devise 1.0.0.alpha3 → 1.0.0

data/spec/matchers/be_a_registerable_spec.rb

@@ -0,0 +1,27 @@
+require "spec_helper"
+
+describe Remarkable::Devise::Matchers::BeARegisterableMatcher do
+  describe "validate inclusion of Devise::Models::Registerable module" do
+    it "should validate that a model has Devise::Models::Registerable included" do
+      subject.matches?(User).should be_true
+    end
+
+    it "should validate that a model hasn't Devise::Models::Registerable included" do
+      subject.matches?(FooUser).should be_false
+    end
+  end
+
+  describe "description" do
+    specify { subject.description.should eql("be a registerable") }
+  end
+
+  describe "failure message" do
+    context "when a model hasn't Devise::Models::Registerable module included" do
+      before do
+        subject.matches?(FooUser)
+      end
+
+      specify { subject.failure_message_for_should.should match("Foo user to have Devise :registerable model") }
+    end
+  end
+end

data/spec/matchers/be_a_rememberable_spec.rb

@@ -17,6 +17,38 @@ describe Remarkable::Devise::Matchers::BeARememberableMatcher do
     end
   end
 
+  context "options validation" do
+    describe :remember_for do
+      it "should validate that a model has proper :remember_for option" do
+        subject.class.new(:remember_for => 2.weeks).matches?(User).should be_true
+      end
+
+      it "should validate that a model hasn't proper :remember_for option" do
+        subject.class.new(:remember_for => 1.month).matches?(User).should be_false
+      end
+    end
+
+    describe :extend_remember_period do
+      it "should validate that a model is configured with proper :remember_across_browsers option" do
+        subject.class.new(:extend_remember_period => true).matches?(User).should be_true
+      end
+
+      it "should validate that a model isn't configured with proper :remember_across_browsers option" do
+        subject.class.new(:extend_remember_period => false).matches?(User).should be_false
+      end
+    end
+
+    describe :cookie_domain do
+      it "should validate that a model is configured with proper :cookie_domain option" do
+        subject.class.new(:cookie_domain => 'foo').matches?(User).should be_true
+      end
+
+      it "should validate that a model isn't configured with proper :cookie_domain option" do
+        subject.class.new(:cookie_domain => 'bar').matches?(User).should be_false
+      end
+    end
+  end
+
   context "columns validation" do
     before do
       subject.stubs(:included?).returns(true)
@@ -52,7 +84,47 @@ describe Remarkable::Devise::Matchers::BeARememberableMatcher do
   end
 
   describe "description" do
-    specify { subject.description.should eql('be a rememberable') }
+    context "when matching without options" do
+      specify { subject.description.should eql('be a rememberable') }
+    end
+
+    context "when matching with :remember_for option" do
+      before do
+        @matcher = subject.class.new(:remember_for => 2.weeks)
+        @matcher.matches?(User)
+      end
+
+      specify { @matcher.description.should eql('be a rememberable with 14 days remember period') }
+    end
+
+    context "when matching with :extend_remember_period" do
+      context "positive" do
+        before do
+          @matcher = subject.class.new(:extend_remember_period => true)
+          @matcher.matches?(User)
+        end
+
+        specify { @matcher.description.should eql('be a rememberable with extendable remember period') }
+      end
+
+      context "negative" do
+        before do
+          @matcher = subject.class.new(:extend_remember_period => false)
+          @matcher.matches?(User)
+        end
+
+        specify { @matcher.description.should eql('be a rememberable without extandable remember period') }
+      end
+    end
+
+    context "when matching with :cookie_domain option" do
+      before do
+        @matcher = subject.class.new(:cookie_domain => 'foo')
+        @matcher.matches?(User)
+      end
+
+      specify { @matcher.description.should eql('be a rememberable with "foo" cookie domain') }
+    end
   end
 
   describe "expectation message" do
@@ -83,5 +155,13 @@ describe Remarkable::Devise::Matchers::BeARememberableMatcher do
       specify { subject.failure_message_for_should.should match('to have remember_created_at column') }
     end
 
+    context "when a model doesn't match given options" do
+      before do
+        @matcher = subject.class.new(:remember_for => 2.weeks, :cookie_domain => 'bar')
+        @matcher.matches?(User)
+      end
+
+      specify { @matcher.failure_message_for_should.should match('User to be rememberable with options (.+), got (.+)') }
+    end
   end
 end

data/spec/matchers/be_a_timeoutable_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe Remarkable::Devise::Matchers::BeATimeoutableMatcher do
+  describe "validate inclusion of Devise::Models::Timeoutable" do
+    it "should validate that model is include Devise::Models::Timeoutable module" do
+      subject.matches?(User).should be_true
+    end
+
+    it "should validate that model isn't include Devise::Models::Timeoutable module" do
+      subject.matches?(FooUser).should be_false
+    end
+  end
+
+  describe "options validation" do
+    describe :timeout_in do
+      it "should validate that model is timeoutable with proper :timeout_in option" do
+        subject.class.new(:timeout_in => 15.minutes).matches?(User).should be_true
+      end
+
+      it "should validate that model is timeoutable without proper :timeout_in option" do
+        subject.class.new(:timeout_in => 5.minutes).matches?(User).should be_false
+      end
+    end
+  end
+
+  describe "description" do
+    context "when matching without options" do
+      specify { subject.description.should eql("be a timeoutable") }
+    end
+
+    context "when matching with :timeout_in option" do
+      before do
+        @matcher = subject.class.new(:timeout_in => 15.minutes)
+        @matcher.matches?(User)
+      end
+
+      specify { @matcher.description.should eql("be a timeoutable within 900 seconds") }
+    end
+  end
+
+  describe "expectation message" do
+    context "when model hasn't Devise::Models::Timeoutable module included" do
+      before do
+        subject.matches?(FooUser)
+      end
+
+      specify { subject.failure_message_for_should.should match("Foo user to include Devise :timeoutable model") }
+    end
+    
+    context "when model doesn't match options" do
+      before do
+        @matcher = subject.class.new(:timeout_in => 5.minutes)
+        @matcher.matches?(User)
+      end
+
+      specify { @matcher.failure_message_for_should.should match("User to be a timeoutable with options (.+), got (.+)") }
+    end
+  end
+end

data/spec/matchers/be_a_token_authenticatable_spec.rb

@@ -17,6 +17,18 @@ describe Remarkable::Devise::Matchers::BeATokenAuthenticatableMatcher do
     end
   end
 
+  describe "options validation" do
+    describe :token_authentication_key do
+      it "should validate that model is configured with proper :token_authentication_key option" do
+        subject.class.new(:token_authentication_key => :auth_token).matches?(User).should be_true
+      end
+
+      it "should validate that model isn't configured with proper :token_authentication_key option" do
+        subject.class.new(:token_authentication_key => :authen_foo_key).matches?(User).should be_false
+      end
+    end
+  end
+
   context "columns validation" do
     before do
       subject.stubs(:included?).returns(true)
@@ -36,7 +48,18 @@ describe Remarkable::Devise::Matchers::BeATokenAuthenticatableMatcher do
   end
 
   describe "description" do
-    specify { subject.description.should eql('be a token authenticatable') }
+    context "when matching without options" do
+      specify { subject.description.should eql('be a token authenticatable') }
+    end
+
+    context "when matching with :token_authentication_key option" do
+      before do
+        @matcher = subject.class.new(:token_authentication_key => :auth_token)
+        @matcher.matches?(User)
+      end
+
+      specify { @matcher.description.should eql("be a token authenticatable with :auth_token as token authentication key") }
+    end
   end
 
   describe "expectation message" do
@@ -56,5 +79,14 @@ describe Remarkable::Devise::Matchers::BeATokenAuthenticatableMatcher do
 
       specify { subject.failure_message_for_should.should match("to have authentication_token column") }
     end
+
+    context "when options doesn't match" do
+      before do
+        @matcher = subject.class.new(:token_authentication_key => :auth_foo_key)
+        @matcher.matches?(User)
+      end
+
+      specify { @matcher.failure_message_for_should.should match("User to be a token authenticatable with options (.+), got (.+)") }
+    end
   end
 end

data/spec/matchers/be_a_validatable_spec.rb

@@ -11,15 +11,68 @@ describe Remarkable::Devise::Matchers::BeAValidatableMatcher do
     end
   end
 
+  context "options matching" do
+    describe :password_length do
+      it "should validate that model is configured with proper :password_length option" do
+        subject.class.new(:password_length => 8..20).matches?(User).should be_true
+      end
+
+      it "should validate that model isn't configured with proper :password_length option" do
+        subject.class.new(:password_length => 4..10).matches?(User).should be_false
+      end
+    end
+
+    describe :email_regexp do
+      it "should validate that model is configured with proper :email_regexp option" do
+        subject.class.new(:email_regexp => /^([\w\.%\+\-]+)@([\w\-]+\.)+([\w]{2,})$/i).matches?(User).should be_true
+      end
+
+      it "should validate that model isn't configured with proper :email_regexp option" do
+        subject.class.new(:email_regexp => /^(.+)@(.+)$/).matches?(User).should be_false
+      end
+    end
+  end
+
   context "description" do
-    specify { subject.description.should eql('be a validatable') }
+    context "when matching without options" do
+      specify { subject.description.should eql('be a validatable') }
+    end
+
+    context "when matching with :password_length option" do
+      before do
+        @matcher = subject.class.new(:password_length => 8..20)
+        @matcher.matches?(User)
+      end
+
+      specify { @matcher.description.should eql("be a validatable with password length 8..20") }
+    end
+
+    context "when matching with :email_regexp option" do
+      before do
+        @matcher = subject.class.new(:email_regexp => /^(.+)@(.+)$/i)
+        @matcher.matches?(User)
+      end
+
+      specify { @matcher.description.should eql("be a validatable with email regexp /^(.+)@(.+)$/i") }
+    end
   end
 
-  context "expectation message" do
-    before do
-      subject.matches?(FooUser)
+  describe "expectation message" do
+    context "when Devise::Models::Validatable is not included" do
+      before do
+        subject.matches?(FooUser)
+      end
+
+      specify { subject.failure_message_for_should.should match('Foo user to include Devise :validatable model')}
     end
 
-    specify { subject.failure_message_for_should.should match('to include Devise :validatable model')}
+    context "when options doesn't match" do
+      before do
+        @matcher = subject.class.new(:password_length => 4..18)
+        @matcher.matches?(User)
+      end
+
+      specify { @matcher.failure_message_for_should.should match('User to be a validatable with options (.+), got (.+)') }
+    end
   end
 end

data/spec/matchers_spec.rb

@@ -3,13 +3,13 @@ require 'spec_helper'
 describe Remarkable::Devise::Matchers do
   describe "#be_a_database_authenticatable" do
     it "should return Remarkable::Devise::Matchers::BeADatabaseAuthenticatableMatcher" do
-      be_a_database_authenticatable.should be_an_instance_of(Remarkable::Devise::Matchers::BeADatabaseAuthenticatableMatcher)
+      be_a_database_authenticatable(:stretches => 10).should be_an_instance_of(Remarkable::Devise::Matchers::BeADatabaseAuthenticatableMatcher)
     end
   end
 
   describe "#be_a_confirmable" do
     it "should return Remarkable::Devise::Matchers::BeAConfirmableMatcher" do
-      be_a_confirmable.should be_an_instance_of(Remarkable::Devise::Matchers::BeAConfirmableMatcher)
+      be_a_confirmable(:confirm_within => 2.days).should be_an_instance_of(Remarkable::Devise::Matchers::BeAConfirmableMatcher)
     end
   end
 
@@ -21,7 +21,7 @@ describe Remarkable::Devise::Matchers do
   
   describe "#be_a_rememberable" do
     it "should return Remarkable::Devise::Matchers::BeARememberableMatcher" do
-      be_a_rememberable.should be_an_instance_of(Remarkable::Devise::Matchers::BeARememberableMatcher)
+      be_a_rememberable(:remember_for => 2.weeks).should be_an_instance_of(Remarkable::Devise::Matchers::BeARememberableMatcher)
     end
   end
 
@@ -33,13 +33,31 @@ describe Remarkable::Devise::Matchers do
 
   describe "#be_a_validatable" do
     it "should return Remarkable::Devise::Matchers::BeAValidatableMatcher" do
-      be_a_validatable.should be_an_instance_of(Remarkable::Devise::Matchers::BeAValidatableMatcher)
+      be_a_validatable(:password_length => 8..20).should be_an_instance_of(Remarkable::Devise::Matchers::BeAValidatableMatcher)
     end
   end
 
   describe "#be_a_token_authenticatable" do
     it "should return Remarkable::Devise::Matchers::BeATokenAuthenticatableMatcher" do
-      be_a_token_authenticatable.should be_an_instance_of(Remarkable::Devise::Matchers::BeATokenAuthenticatableMatcher)
+      be_a_token_authenticatable(:token_authentication_key => :auth_token).should be_an_instance_of(Remarkable::Devise::Matchers::BeATokenAuthenticatableMatcher)
+    end
+  end
+
+  describe "#be_a_timeoutable" do
+    it "should return Remarkable::Devise::Matchers::BeATimeoutableMatcher" do
+      be_a_timeoutable(:timeout_in => 5.minutes).should be_an_instance_of(Remarkable::Devise::Matchers::BeATimeoutableMatcher)
+    end
+  end
+
+  describe "#be_a_lockable" do
+    it "should return Remarkable::Devise::Matchers::BeALockableMatcher" do
+      be_a_lockable(:maximum_attempts => 10).should be_an_instance_of(Remarkable::Devise::Matchers::BeALockableMatcher)
+    end
+  end
+
+  describe "#be_a_registerable" do
+    it "should return Remarkable::Devise::Matchers::BeARegisterableMatcher" do
+      be_a_registerable.should be_an_instance_of(Remarkable::Devise::Matchers::BeARegisterableMatcher)
     end
   end
 end

data/spec/shared_examples.rb

@@ -0,0 +1,122 @@
+shared_examples_for "lockable matcher for unlock_strategy with unlock_token column needed" do
+  context "when a model has :unlock_token column" do
+    it "should match" do
+      subject.matches?(User).should be_true
+    end
+  end
+
+  context "when a model has no :unlock_token column" do
+    before do
+      User.stubs(:column_names).returns(@valid_columns - ['unlock_token'])
+    end
+
+    it "should not match" do
+      subject.matches?(User).should be_false
+    end
+  end
+end
+
+shared_examples_for "lockable matcher for unlock_strategy without unlock_token column needed" do
+  context "when a model has :unlock_token column" do
+    it "should match" do
+      subject.matches?(User).should be_true
+    end
+  end
+
+  context "when a model has no :unlock_token column" do
+    before do
+      User.stubs(:column_names).returns(@valid_columns - ['unlock_token'])
+    end
+
+    it "should match" do
+      subject.matches?(User).should be_true
+    end
+  end
+end
+
+shared_examples_for "any Devise authentication model" do
+  describe "validation of Devise::Models::Authenticatable module inclusion" do
+    context "when a model has module included" do
+      it "should match" do
+        subject.matches?(User).should be_true
+      end
+    end
+
+    context "when a model hasn't module included" do
+      it "should not match" do
+        subject.matches?(FooUser).should be_false
+      end
+    end
+  end
+
+  describe "options validation" do
+    describe :authentication_keys do
+      context "when a model has expected :authentication_keys value" do
+        it "should match" do
+          subject.class.new(:authentication_keys => [:email, :login]).matches?(User).should be_true
+        end
+      end
+
+      context "when a model hasn't expected :authentication_keys value" do
+        it "should not match" do
+          subject.class.new(:authentication_keys => [:login]).matches?(User).should be_false
+        end
+      end
+    end
+
+    describe :params_authenticatable do
+      context "when a model has expected :params_authenticatable value" do
+        it "should match" do
+          subject.class.new(:params_authenticatable => false).matches?(User).should be_true
+        end
+      end
+
+      context "when a model hasn't expected :params_authenticatable value" do
+        it "should not match" do
+          subject.class.new(:params_authenticatable => true).matches?(User).should be_false
+        end
+      end
+    end
+  end
+
+  describe "description" do
+    context "when matching with :authentication_keys option" do
+      before do
+        @matcher = subject.class.new(:authentication_keys => [:email, :login])
+        @matcher.matches?(User)
+      end
+
+      specify { @matcher.description.should match(/with \[\:email, \:login\] as authentication keys/) }
+    end
+
+    context "when matching with :params_authenticatable option" do
+      context "positive" do
+        before do
+          @matcher = subject.class.new(:params_authenticatable => true)
+          @matcher.matches?(User)
+        end
+
+        specify { @matcher.description.should match(/with params authenticatable/) }
+      end
+
+      context "negative" do
+        before do
+          @matcher = subject.class.new(:params_authenticatable => false)
+          @matcher.matches?(User)
+        end
+
+        specify { @matcher.description.should match(/without params authenticatable/) }
+      end
+    end
+  end
+
+  describe "failure message" do
+    context "when Devise::Models::Authenticatable module isn't included" do
+      before do
+        subject.matches?(FooUser)
+      end
+
+      specify { subject.failure_message_for_should.should match("Foo user to have Devise :authenticatable model") }
+    end
+  end
+end