shoulda-matchers 2.5.0 → 2.6.0

data/spec/shoulda/matchers/active_model/validate_presence_of_matcher_spec.rb

@@ -3,52 +3,52 @@ require 'spec_helper'
 describe Shoulda::Matchers::ActiveModel::ValidatePresenceOfMatcher do
   context 'a model with a presence validation' do
     it 'accepts' do
-      validating_presence.should matcher
+      expect(validating_presence).to matcher
     end
 
     it 'does not override the default message with a blank' do
-      validating_presence.should matcher.with_message(nil)
+      expect(validating_presence).to matcher.with_message(nil)
     end
   end
 
   context 'a model without a presence validation' do
     it 'rejects' do
-      define_model(:example, :attr => :string).new.should_not matcher
+      expect(define_model(:example, attr: :string).new).not_to matcher
     end
   end
 
   context 'an ActiveModel class with a presence validation' do
     it 'accepts' do
-      active_model_validating_presence.should matcher
+      expect(active_model_validating_presence).to matcher
     end
 
     it 'does not override the default message with a blank' do
-      active_model_validating_presence.should matcher.with_message(nil)
+      expect(active_model_validating_presence).to matcher.with_message(nil)
     end
   end
 
   context 'an ActiveModel class without a presence validation' do
     it 'rejects' do
-      active_model.should_not matcher
+      expect(active_model).not_to matcher
     end
 
     it 'provides the correct failure message' do
       message = %{Expected errors to include "can't be blank" when attr is set to nil, got no errors}
 
-      expect { active_model.should matcher }.to fail_with_message(message)
+      expect { expect(active_model).to matcher }.to fail_with_message(message)
     end
   end
 
   context 'a has_many association with a presence validation' do
     it 'requires the attribute to be set' do
-      has_many_children(:presence => true).should validate_presence_of(:children)
+      expect(has_many_children(presence: true)).to validate_presence_of(:children)
     end
   end
 
   context 'a has_many association without a presence validation' do
     it 'does not require the attribute to be set' do
-      has_many_children(:presence => false).
-        should_not validate_presence_of(:children)
+      expect(has_many_children(presence: false)).
+        not_to validate_presence_of(:children)
     end
   end
 
@@ -59,14 +59,14 @@ describe Shoulda::Matchers::ActiveModel::ValidatePresenceOfMatcher do
         has_and_belongs_to_many :children
         validates_presence_of :children
       end.new
-      create_table 'children_parents', :id => false do |t|
+      create_table 'children_parents', id: false do |t|
         t.integer :child_id
         t.integer :parent_id
       end
     end
 
     it 'accepts' do
-      @model.should validate_presence_of(:children)
+      expect(@model).to validate_presence_of(:children)
     end
   end
 
@@ -76,14 +76,14 @@ describe Shoulda::Matchers::ActiveModel::ValidatePresenceOfMatcher do
       @model = define_model :parent do
         has_and_belongs_to_many :children
       end.new
-      create_table 'children_parents', :id => false do |t|
+      create_table 'children_parents', id: false do |t|
         t.integer :child_id
         t.integer :parent_id
       end
     end
 
     it 'rejects' do
-      @model.should_not validate_presence_of(:children)
+      expect(@model).not_to validate_presence_of(:children)
     end
   end
 
@@ -98,7 +98,7 @@ describe Shoulda::Matchers::ActiveModel::ValidatePresenceOfMatcher do
 
     it "does not raise an exception" do
       expect {
-        validating_presence.should validate_presence_of(:attr)
+        expect(validating_presence).to validate_presence_of(:attr)
       }.to_not raise_exception
     end
   end
@@ -106,30 +106,30 @@ describe Shoulda::Matchers::ActiveModel::ValidatePresenceOfMatcher do
   if active_model_3_2?
     context 'a strictly required attribute' do
       it 'accepts when the :strict options match' do
-        validating_presence(:strict => true).should matcher.strict
+        expect(validating_presence(strict: true)).to matcher.strict
       end
 
       it 'rejects when the :strict options do not match' do
-        validating_presence(:strict => false).should_not matcher.strict
+        expect(validating_presence(strict: false)).not_to matcher.strict
       end
     end
 
     it 'does not override the default message with a blank' do
-      validating_presence(:strict => true).
-        should matcher.strict.with_message(nil)
+      expect(validating_presence(strict: true)).
+        to matcher.strict.with_message(nil)
     end
   end
 
   context "an attribute with a context-dependent validation" do
     context "without the validation context" do
       it "does not match" do
-        validating_presence(:on => :customisable).should_not matcher
+        expect(validating_presence(on: :customisable)).not_to matcher
       end
     end
 
     context "with the validation context" do
       it "matches" do
-        validating_presence(:on => :customisable).should matcher.on(:customisable)
+        expect(validating_presence(on: :customisable)).to matcher.on(:customisable)
       end
     end
   end
@@ -138,24 +138,43 @@ describe Shoulda::Matchers::ActiveModel::ValidatePresenceOfMatcher do
     context 'with the validation context' do
       it 'does not raise an exception' do
         expect {
-          active_resource_model.should validate_presence_of(:attr)
+          expect(active_resource_model).to validate_presence_of(:attr)
         }.to_not raise_exception
       end
     end
   end
 
+  if rails_4_x?
+    context 'against a pre-set password in a model that has_secure_password' do
+      it 'raises an error to instruct the user' do
+        user_class = define_model :user, password_digest: :string do
+          has_secure_password
+          validates_presence_of :password
+        end
+
+        user = user_class.new
+        user.password = 'something'
+
+        error_class = Shoulda::Matchers::ActiveModel::CouldNotSetPasswordError
+        expect {
+          expect(user).to validate_presence_of(:password)
+        }.to raise_error(error_class)
+      end
+    end
+  end
+
   def matcher
     validate_presence_of(:attr)
   end
 
   def validating_presence(options = {})
-    define_model :example, :attr => :string do
+    define_model :example, attr: :string do
       validates_presence_of :attr, options
     end.new
   end
 
   def active_model(&block)
-    define_active_model_class('Example', :accessors => [:attr], &block).new
+    define_active_model_class('Example', accessors: [:attr], &block).new
   end
 
   def active_model_validating_presence
@@ -173,7 +192,7 @@ describe Shoulda::Matchers::ActiveModel::ValidatePresenceOfMatcher do
   end
 
   def active_resource_model
-    define_active_resource_class :foo, :attr => :string do
+    define_active_resource_class :foo, attr: :string do
       validates_presence_of :attr
     end.new
   end

data/spec/shoulda/matchers/active_model/validate_uniqueness_of_matcher_spec.rb

@@ -5,7 +5,7 @@ describe Shoulda::Matchers::ActiveModel::ValidateUniquenessOfMatcher do
     it 'rejects' do
       model = define_model(:example, attr: :string) { attr_accessible :attr } .new
       Example.create!(attr: 'value')
-      model.should_not matcher
+      expect(model).not_to matcher
     end
   end
 
@@ -16,23 +16,23 @@ describe Shoulda::Matchers::ActiveModel::ValidateUniquenessOfMatcher do
          attr_accessible :attr
          validates_uniqueness_of :attr
         end.new
-        model.should matcher
+        expect(model).to matcher
       end
     end
 
     context 'with an existing record' do
       it 'requires a unique value for that attribute' do
         create_existing
-        validating_uniqueness_with_other.should matcher
+        expect(validating_uniqueness_with_other).to matcher
       end
 
       it 'accepts when the subject is an existing record' do
-        create_existing.should matcher
+        expect(create_existing).to matcher
       end
 
       it 'rejects when a scope is specified' do
         create_existing
-        validating_uniqueness_with_other.should_not matcher.scoped_to(:other)
+        expect(validating_uniqueness_with_other).not_to matcher.scoped_to(:other)
       end
 
       def create_existing
@@ -44,8 +44,8 @@ describe Shoulda::Matchers::ActiveModel::ValidateUniquenessOfMatcher do
     context 'without an existing record' do
       it 'does not require a created instance' do
         define_model_with_other
-        Example.count.should eq 0
-        validating_uniqueness_with_other.should matcher
+        expect(Example.count).to eq 0
+        expect(validating_uniqueness_with_other).to matcher
       end
     end
 
@@ -63,18 +63,18 @@ describe Shoulda::Matchers::ActiveModel::ValidateUniquenessOfMatcher do
 
   context 'a model with a uniqueness validation, a custom error, and an existing record' do
     it 'rejects when the actual message does not match the default message' do
-      validating_uniqueness_with_existing_record(message: 'Bad value').
-        should_not matcher
+      expect(validating_uniqueness_with_existing_record(message: 'Bad value')).
+        not_to matcher
     end
 
     it 'rejects when the messages do not match' do
-      validating_uniqueness_with_existing_record(message: 'Bad value').
-        should_not matcher.with_message(/abc/)
+      expect(validating_uniqueness_with_existing_record(message: 'Bad value')).
+        not_to matcher.with_message(/abc/)
     end
 
     it 'accepts when the messages match' do
-      validating_uniqueness_with_existing_record(message: 'Bad value').
-        should matcher.with_message(/Bad/)
+      expect(validating_uniqueness_with_existing_record(message: 'Bad value')).
+        to matcher.with_message(/Bad/)
     end
 
     def validating_uniqueness_with_existing_record(options = {})
@@ -89,119 +89,119 @@ describe Shoulda::Matchers::ActiveModel::ValidateUniquenessOfMatcher do
 
   context 'a model with a scoped uniqueness validation with an existing value' do
     it 'accepts when the correct scope is specified' do
-      validating_scoped_uniqueness([:scope1, :scope2]).
-        should matcher.scoped_to(:scope1, :scope2)
+      expect(validating_scoped_uniqueness([:scope1, :scope2])).
+        to matcher.scoped_to(:scope1, :scope2)
     end
 
     it 'accepts when the subject is an existing record' do
       define_scoped_model([:scope1, :scope2])
-      create_existing_record.should matcher.scoped_to(:scope1, :scope2)
+      expect(create_existing_record).to matcher.scoped_to(:scope1, :scope2)
     end
 
     it 'rejects when too narrow of a scope is specified' do
-      validating_scoped_uniqueness([:scope1, :scope2]).
-        should_not matcher.scoped_to(:scope1, :scope2, :other)
+      expect(validating_scoped_uniqueness([:scope1, :scope2])).
+        not_to matcher.scoped_to(:scope1, :scope2, :other)
     end
 
     it 'rejects when too broad of a scope is specified' do
-      validating_scoped_uniqueness([:scope1, :scope2]).
-        should_not matcher.scoped_to(:scope1)
+      expect(validating_scoped_uniqueness([:scope1, :scope2])).
+        not_to matcher.scoped_to(:scope1)
     end
 
     it 'rejects when a different scope is specified' do
-      validating_scoped_uniqueness([:scope1]).
-        should_not matcher.scoped_to(:other)
+      expect(validating_scoped_uniqueness([:scope1])).
+        not_to matcher.scoped_to(:other)
     end
 
     it 'rejects when no scope is specified' do
-      validating_scoped_uniqueness([:scope1]).should_not matcher
+      expect(validating_scoped_uniqueness([:scope1])).not_to matcher
     end
 
     it 'rejects when a non-existent attribute is specified as a scope' do
-      validating_scoped_uniqueness([:scope1]).
-        should_not matcher.scoped_to(:fake)
+      expect(validating_scoped_uniqueness([:scope1])).
+        not_to matcher.scoped_to(:fake)
     end
 
     context 'when the scoped attribute is a date' do
       it "accepts" do
-        validating_scoped_uniqueness([:scope1], :date, scope1: Date.today).
-          should matcher.scoped_to(:scope1)
+        expect(validating_scoped_uniqueness([:scope1], :date, scope1: Date.today)).
+          to matcher.scoped_to(:scope1)
       end
 
       context 'with an existing record that conflicts with scope.next' do
         it 'accepts' do
-          validating_scoped_uniqueness_with_conflicting_next(:scope1, :date, scope1: Date.today).
-            should matcher.scoped_to(:scope1)
+          expect(validating_scoped_uniqueness_with_conflicting_next(:scope1, :date, scope1: Date.today)).
+            to matcher.scoped_to(:scope1)
         end
       end
 
       context 'when too narrow of a scope is specified' do
         it 'rejects' do
-          validating_scoped_uniqueness([:scope1, :scope2], :date, scope1: Date.today, scope2: Date.today).
-            should_not matcher.scoped_to(:scope1, :scope2, :other)
+          expect(validating_scoped_uniqueness([:scope1, :scope2], :date, scope1: Date.today, scope2: Date.today)).
+            not_to matcher.scoped_to(:scope1, :scope2, :other)
         end
       end
 
       context 'when too broad of a scope is specified' do
         it 'rejects' do
-          validating_scoped_uniqueness([:scope1, :scope2], :date, scope1: Date.today, scope2: Date.today).
-            should_not matcher.scoped_to(:scope1)
+          expect(validating_scoped_uniqueness([:scope1, :scope2], :date, scope1: Date.today, scope2: Date.today)).
+            not_to matcher.scoped_to(:scope1)
         end
       end
     end
 
     context 'when the scoped attribute is a datetime' do
       it 'accepts' do
-        validating_scoped_uniqueness([:scope1], :datetime, scope1: DateTime.now).
-          should matcher.scoped_to(:scope1)
+        expect(validating_scoped_uniqueness([:scope1], :datetime, scope1: DateTime.now)).
+          to matcher.scoped_to(:scope1)
       end
 
       context 'with an existing record that conflicts with scope.next' do
         it 'accepts' do
-          validating_scoped_uniqueness_with_conflicting_next(:scope1, :datetime, scope1: DateTime.now).
-            should matcher.scoped_to(:scope1)
+          expect(validating_scoped_uniqueness_with_conflicting_next(:scope1, :datetime, scope1: DateTime.now)).
+            to matcher.scoped_to(:scope1)
         end
       end
 
       context 'with a nil value' do
         it 'accepts' do
-          validating_scoped_uniqueness([:scope1], :datetime, scope1: nil).
-            should matcher.scoped_to(:scope1)
+          expect(validating_scoped_uniqueness([:scope1], :datetime, scope1: nil)).
+            to matcher.scoped_to(:scope1)
         end
       end
 
       context 'when too narrow of a scope is specified' do
         it 'rejects' do
-          validating_scoped_uniqueness([:scope1, :scope2], :datetime, scope1: DateTime.now, scope2: DateTime.now).
-            should_not matcher.scoped_to(:scope1, :scope2, :other)
+          expect(validating_scoped_uniqueness([:scope1, :scope2], :datetime, scope1: DateTime.now, scope2: DateTime.now)).
+            not_to matcher.scoped_to(:scope1, :scope2, :other)
         end
       end
 
       context 'when too broad of a scope is specified' do
         it 'rejects' do
-          validating_scoped_uniqueness([:scope1, :scope2], :datetime, scope1: DateTime.now, scope2: DateTime.now).
-            should_not matcher.scoped_to(:scope1)
+          expect(validating_scoped_uniqueness([:scope1, :scope2], :datetime, scope1: DateTime.now, scope2: DateTime.now)).
+            not_to matcher.scoped_to(:scope1)
         end
       end
     end
 
     context 'when the scoped attribute is a uuid' do
       it 'accepts' do
-        validating_scoped_uniqueness([:scope1], :uuid, scope1: SecureRandom.uuid).
-          should matcher.scoped_to(:scope1)
+        expect(validating_scoped_uniqueness([:scope1], :uuid, scope1: SecureRandom.uuid)).
+          to matcher.scoped_to(:scope1)
       end
 
       context 'with an existing record that conflicts with scope.next' do
         it 'accepts' do
-          validating_scoped_uniqueness_with_conflicting_next(:scope1, :uuid, scope1: SecureRandom.uuid).
-            should matcher.scoped_to(:scope1)
+          expect(validating_scoped_uniqueness_with_conflicting_next(:scope1, :uuid, scope1: SecureRandom.uuid)).
+            to matcher.scoped_to(:scope1)
         end
       end
 
       context 'with a nil value' do
         it 'accepts' do
-          validating_scoped_uniqueness([:scope1], :uuid, scope1: nil).
-            should matcher.scoped_to(:scope1)
+          expect(validating_scoped_uniqueness([:scope1], :uuid, scope1: nil)).
+            to matcher.scoped_to(:scope1)
         end
       end
 
@@ -211,7 +211,7 @@ describe Shoulda::Matchers::ActiveModel::ValidateUniquenessOfMatcher do
             scope1: SecureRandom.uuid,
             scope2: SecureRandom.uuid
           )
-          record.should_not matcher.scoped_to(:scope1, :scope2, :other)
+          expect(record).not_to matcher.scoped_to(:scope1, :scope2, :other)
         end
       end
 
@@ -221,7 +221,7 @@ describe Shoulda::Matchers::ActiveModel::ValidateUniquenessOfMatcher do
             scope1: SecureRandom.uuid,
             scope2: SecureRandom.uuid
           )
-          record.should_not matcher.scoped_to(:scope1)
+          expect(record).not_to matcher.scoped_to(:scope1)
         end
       end
     end
@@ -263,24 +263,24 @@ describe Shoulda::Matchers::ActiveModel::ValidateUniquenessOfMatcher do
 
   context 'a model with a case-sensitive uniqueness validation on a string attribute and an existing record' do
     it 'accepts a case-sensitive value for that attribute' do
-      case_sensitive_validation_with_existing_value(:string).
-        should matcher
+      expect(case_sensitive_validation_with_existing_value(:string)).
+        to matcher
     end
 
     it 'rejects a case-insensitive value for that attribute' do
-      case_sensitive_validation_with_existing_value(:string).
-        should_not matcher.case_insensitive
+      expect(case_sensitive_validation_with_existing_value(:string)).
+        not_to matcher.case_insensitive
     end
   end
 
   context 'a model with a case-sensitive uniqueness validation on an integer attribute with an existing value' do
     it 'accepts a case-insensitive value for that attribute' do
-      case_sensitive_validation_with_existing_value(:integer).
-        should matcher.case_insensitive
+      expect(case_sensitive_validation_with_existing_value(:integer)).
+        to matcher.case_insensitive
     end
 
     it 'accepts a case-sensitive value for that attribute' do
-      case_sensitive_validation_with_existing_value(:integer).should matcher
+      expect(case_sensitive_validation_with_existing_value(:integer)).to matcher
     end
   end
 
@@ -289,13 +289,25 @@ describe Shoulda::Matchers::ActiveModel::ValidateUniquenessOfMatcher do
       it "should allow_nil" do
         model = define_model_with_allow_nil
         Example.create!(attr: nil)
-        model.should matcher.allow_nil
+        expect(model).to matcher.allow_nil
+      end
+    end
+
+    if active_model_3_1?
+      context 'when the subject has a secure password' do
+        it 'allows nil on the attribute' do
+          model = define_model(:example, attr: :string, password_digest: :string) do |m|
+            validates_uniqueness_of :attr, allow_nil: true
+            has_secure_password
+          end.new
+          expect(model).to matcher.allow_nil
+        end
       end
     end
 
     it "should create a nil and verify that it is allowed" do
       model = define_model_with_allow_nil
-      model.should matcher.allow_nil
+      expect(model).to matcher.allow_nil
       Example.all.any?{ |instance| instance.attr.nil? }
     end
 
@@ -312,13 +324,13 @@ describe Shoulda::Matchers::ActiveModel::ValidateUniquenessOfMatcher do
       it "should not allow_nil" do
         model = define_model_without_allow_nil
         Example.create!(attr: nil)
-        model.should_not matcher.allow_nil
+        expect(model).not_to matcher.allow_nil
       end
     end
 
     it "should not allow_nil" do
       model = define_model_without_allow_nil
-      model.should_not matcher.allow_nil
+      expect(model).not_to matcher.allow_nil
     end
 
     def define_model_without_allow_nil
@@ -329,6 +341,42 @@ describe Shoulda::Matchers::ActiveModel::ValidateUniquenessOfMatcher do
     end
   end
 
+  context "a model with non-nullable attribute" do
+    context "of type" do
+      [:string, :text, :integer, :float, :decimal, :datetime, :timestamp, :time, :date, :binary, :boolean].each do |type|
+        context type do
+          it "does not raise an error" do
+            model = define_model_with_non_nullable(type)
+            expect { expect(model).to matcher }.not_to raise_error
+          end
+        end
+      end
+    end
+
+    context "that is a primary key" do
+      it "does not cause duplicate entry errors by re-using default values for primary keys" do
+        create_table :examples, id: false do |t|
+          t.string :attr
+          t.integer :non_nullable, primary: true
+        end
+        model_class = define_model(:example, attr: :string) do
+          validates_uniqueness_of :attr
+        end
+        model_1 = model_class.new
+        model_2 = model_class.new
+        expect(model_1).to matcher
+        expect { expect(model_2).to matcher }.not_to raise_error 
+      end
+    end
+
+    def define_model_with_non_nullable(type)
+      define_model(:example, attr: :string, non_nullable: { type: type, options: { null: false } }) do
+        attr_accessible :attr, :non_nullable
+        validates_uniqueness_of :attr
+      end.new
+    end
+  end
+
   def case_sensitive_validation_with_existing_value(attr_type)
     model = define_model(:example, attr: attr_type) do
       attr_accessible :attr