shoulda-matchers 2.4.0 → 2.5.0

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

@@ -98,6 +98,13 @@ describe Shoulda::Matchers::ActiveModel::EnsureLengthOfMatcher do
     end
   end
 
+  context 'an attribute with a custom equal validation' do
+    it 'accepts ensuring the correct exact length' do
+      validating_length(:is => 4, :message => 'foobar').
+        should ensure_length_of(:attr).is_equal_to(4).with_message(/foo/)
+    end
+  end
+
   context 'an attribute without a length validation' do
     it 'rejects ensuring a minimum length' do
       define_model(:example, :attr => :string).new.

data/spec/shoulda/matchers/active_model/{comparison_matcher_spec.rb → numericality_matchers/comparison_matcher_spec.rb}

@@ -1,8 +1,8 @@
 require 'spec_helper'
 
-describe Shoulda::Matchers::ActiveModel::ComparisonMatcher do
+describe Shoulda::Matchers::ActiveModel::NumericalityMatchers::ComparisonMatcher do
   it_behaves_like 'a numerical submatcher' do
-    subject {  Shoulda::Matchers::ActiveModel::ComparisonMatcher.new(0, :>) }
+    subject { described_class.new(0, :>) }
   end
 
   context 'is_greater_than' do

data/spec/shoulda/matchers/active_model/{odd_even_number_matcher_spec.rb → numericality_matchers/odd_even_number_matcher_spec.rb}

@@ -1,8 +1,8 @@
 require 'spec_helper'
 
-describe Shoulda::Matchers::ActiveModel::OddEvenNumberMatcher do
+describe Shoulda::Matchers::ActiveModel::NumericalityMatchers::OddEvenNumberMatcher do
   it_behaves_like 'a numerical submatcher' do
-    subject {  Shoulda::Matchers::ActiveModel::OddEvenNumberMatcher.new(:attr) }
+    subject { described_class.new(:attr) }
   end
 
   context 'given an attribute that only allows odd number values' do
@@ -57,7 +57,7 @@ describe Shoulda::Matchers::ActiveModel::OddEvenNumberMatcher do
 
       matcher.matches?(define_model(:example, :attr => :string).new)
 
-      matcher.failure_message_for_should.should include 'Expected errors to include "must be odd"'
+      matcher.failure_message.should include 'Expected errors to include "must be odd"'
     end
   end
 
@@ -71,7 +71,7 @@ describe Shoulda::Matchers::ActiveModel::OddEvenNumberMatcher do
 
       matcher.matches?(define_model(:example, :attr => :string).new)
 
-      matcher.failure_message_for_should.should include 'Expected errors to include "must be even"'
+      matcher.failure_message.should include 'Expected errors to include "must be even"'
     end
   end
 

data/spec/shoulda/matchers/active_model/{only_integer_matcher_spec.rb → numericality_matchers/only_integer_matcher_spec.rb}

@@ -1,8 +1,8 @@
 require 'spec_helper'
 
-describe Shoulda::Matchers::ActiveModel::OnlyIntegerMatcher do
+describe Shoulda::Matchers::ActiveModel::NumericalityMatchers::OnlyIntegerMatcher do
   it_behaves_like 'a numerical submatcher' do
-    subject { Shoulda::Matchers::ActiveModel::OnlyIntegerMatcher.new(:attr) }
+    subject { described_class.new(:attr) }
   end
 
   context 'given an attribute that only allows integer values' do
@@ -40,7 +40,7 @@ describe Shoulda::Matchers::ActiveModel::OnlyIntegerMatcher do
 
       matcher.matches?(define_model(:example, :attr => :string).new)
 
-      matcher.failure_message_for_should.should include 'Expected errors to include "must be an integer"'
+      matcher.failure_message.should include 'Expected errors to include "must be an integer"'
     end
   end
 

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

@@ -0,0 +1,139 @@
+require 'spec_helper'
+
+describe Shoulda::Matchers::ActiveModel::ValidateAbsenceOfMatcher do
+  if active_model_4_0?
+    context 'a model with an absence validation' do
+      it 'accepts' do
+        validating_absence_of(:attr).should validate_absence_of(:attr)
+      end
+
+      it 'does not override the default message with a present' do
+        validating_absence_of(:attr).should validate_absence_of(:attr).with_message(nil)
+      end
+    end
+
+    context 'a model without an absence validation' do
+      it 'rejects' do
+        model = define_model(:example, attr: :string).new
+        model.should_not validate_absence_of(:attr)
+      end
+    end
+
+    context 'an ActiveModel class with an absence validation' do
+      it 'accepts' do
+        active_model_validating_absence_of(:attr).should validate_absence_of(:attr)
+      end
+
+      it 'does not override the default message with a blank' do
+        active_model_validating_absence_of(:attr).should validate_absence_of(:attr).with_message(nil)
+      end
+    end
+
+    context 'an ActiveModel class without an absence validation' do
+      it 'rejects' do
+        active_model_with(:attr).should_not validate_absence_of(:attr)
+      end
+
+      it 'provides the correct failure message' do
+        message = %{Expected errors to include "must be blank" when attr is set to "an arbitrary value", got no errors}
+
+        expect { active_model_with(:attr).should validate_absence_of(:attr) }.to fail_with_message(message)
+      end
+    end
+
+    context 'a has_many association with an absence validation' do
+      it 'requires the attribute to not be set' do
+        having_many(:children, absence: true).should validate_absence_of(:children)
+      end
+    end
+
+    context 'a has_many association without an absence validation' do
+      it 'does not require the attribute to not be set' do
+        having_many(:children, absence: false).
+          should_not validate_absence_of(:children)
+      end
+    end
+
+    context 'an absent has_and_belongs_to_many association' do
+      it 'accepts' do
+        model = having_and_belonging_to_many(:children, absence: true)
+        model.should validate_absence_of(:children)
+      end
+    end
+
+    context 'a non-absent has_and_belongs_to_many association' do
+      it 'rejects' do
+        model = having_and_belonging_to_many(:children, absence: false)
+        model.should_not validate_absence_of(:children)
+      end
+    end
+
+    context "an i18n translation containing %{attribute} and %{model}" do
+      after { I18n.backend.reload! }
+
+      it "does not raise an exception" do
+        stub_translation("activerecord.errors.messages.present",
+                         "%{attribute} must be blank in a %{model}")
+
+        expect {
+          validating_absence_of(:attr).should validate_absence_of(:attr)
+        }.to_not raise_exception
+      end
+    end
+
+    context "an attribute with a context-dependent validation" do
+      context "without the validation context" do
+        it "does not match" do
+          validating_absence_of(:attr, on: :customisable).should_not validate_absence_of(:attr)
+        end
+      end
+
+      context "with the validation context" do
+        it "matches" do
+          validating_absence_of(:attr, on: :customisable).should validate_absence_of(:attr).on(:customisable)
+        end
+      end
+    end
+
+    def validating_absence_of(attr, options = {})
+      define_model :example, attr => :string do
+        validates_absence_of attr, options
+      end.new
+    end
+
+    def active_model_with(attr, &block)
+      define_active_model_class('Example', accessors: [attr], &block).new
+    end
+
+    def active_model_validating_absence_of(attr)
+      active_model_with(attr) do
+        validates_absence_of attr
+      end
+    end
+
+    def having_many(plural_name, options = {})
+      define_model plural_name.to_s.singularize
+      define_model :parent do
+        has_many plural_name
+        if options[:absence]
+          validates_absence_of plural_name
+        end
+      end.new
+    end
+
+    def having_and_belonging_to_many(plural_name, options = {})
+      create_table 'children_parents', id: false do |t|
+        t.integer "#{plural_name.to_s.singularize}_id"
+        t.integer :parent_id
+      end
+
+      define_model plural_name.to_s.singularize
+      define_model :parent do
+        has_and_belongs_to_many plural_name
+        if options[:absence]
+          validates_absence_of plural_name
+        end
+      end.new
+    end
+  end
+end

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

@@ -27,7 +27,7 @@ describe Shoulda::Matchers::ActiveModel::ValidateNumericalityOfMatcher do
 
       the_matcher.matches?(define_model(:example, :attr => :string).new)
 
-      the_matcher.failure_message_for_should_not.should include 'Did not expect errors to include "is not a number"'
+      the_matcher.failure_message_when_negated.should include 'Did not expect errors to include "is not a number"'
     end
 
     it 'rejects with the ActiveRecord :not_an_integer message' do
@@ -35,7 +35,7 @@ describe Shoulda::Matchers::ActiveModel::ValidateNumericalityOfMatcher do
 
       the_matcher.matches?(define_model(:example, :attr => :string).new)
 
-      the_matcher.failure_message_for_should.should include 'Expected errors to include "must be an integer"'
+      the_matcher.failure_message.should include 'Expected errors to include "must be an integer"'
     end
 
     it 'rejects with the ActiveRecord :odd message' do
@@ -43,7 +43,7 @@ describe Shoulda::Matchers::ActiveModel::ValidateNumericalityOfMatcher do
 
       the_matcher.matches?(define_model(:example, :attr => :string).new)
 
-      the_matcher.failure_message_for_should.should include 'Expected errors to include "must be odd"'
+      the_matcher.failure_message.should include 'Expected errors to include "must be odd"'
     end
 
     it 'rejects with the ActiveRecord :even message' do
@@ -51,7 +51,7 @@ describe Shoulda::Matchers::ActiveModel::ValidateNumericalityOfMatcher do
 
       the_matcher.matches?(define_model(:example, :attr => :string).new)
 
-      the_matcher.failure_message_for_should.should include 'Expected errors to include "must be even"'
+      the_matcher.failure_message.should include 'Expected errors to include "must be even"'
     end
   end
 
@@ -69,7 +69,7 @@ describe Shoulda::Matchers::ActiveModel::ValidateNumericalityOfMatcher do
 
       the_matcher.matches?(validating_numericality)
 
-      the_matcher.failure_message_for_should.should include 'Expected errors to include "must be an integer"'
+      the_matcher.failure_message.should include 'Expected errors to include "must be an integer"'
     end
   end
 
@@ -87,7 +87,7 @@ describe Shoulda::Matchers::ActiveModel::ValidateNumericalityOfMatcher do
 
       the_matcher.matches?(validating_numericality)
 
-      the_matcher.failure_message_for_should.should include 'Expected errors to include "must be odd"'
+      the_matcher.failure_message.should include 'Expected errors to include "must be odd"'
     end
   end
 
@@ -105,7 +105,7 @@ describe Shoulda::Matchers::ActiveModel::ValidateNumericalityOfMatcher do
 
       the_matcher.matches?(validating_numericality)
 
-      the_matcher.failure_message_for_should.should include 'Expected errors to include "must be even"'
+      the_matcher.failure_message.should include 'Expected errors to include "must be even"'
     end
   end
 

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

@@ -3,13 +3,23 @@ require 'spec_helper'
 describe Shoulda::Matchers::ActiveModel::ValidateUniquenessOfMatcher do
   context 'a model without a a uniqueness validation' do
     it 'rejects' do
-      model = define_model(:example, :attr => :string) { attr_accessible :attr } .new
-      Example.create!(:attr => 'value')
+      model = define_model(:example, attr: :string) { attr_accessible :attr } .new
+      Example.create!(attr: 'value')
       model.should_not matcher
     end
   end
 
   context 'a model with a uniqueness validation' do
+    context 'where the subject has a character limit' do
+      it 'tests with values within the character limit' do
+        model = define_model(:example, attr: { type: :string, options: { limit: 1 } }) do
+         attr_accessible :attr
+         validates_uniqueness_of :attr
+        end.new
+        model.should matcher
+      end
+    end
+
     context 'with an existing record' do
       it 'requires a unique value for that attribute' do
         create_existing
@@ -27,7 +37,7 @@ describe Shoulda::Matchers::ActiveModel::ValidateUniquenessOfMatcher do
 
       def create_existing
         define_model_with_other
-        Example.create!(:attr => 'value', :other => 1)
+        Example.create!(attr: 'value', other: 1)
       end
     end
 
@@ -40,7 +50,7 @@ describe Shoulda::Matchers::ActiveModel::ValidateUniquenessOfMatcher do
     end
 
     def define_model_with_other(options = {})
-      @model ||= define_model(:example, :attr => :string, :other => :integer) do
+      @model ||= define_model(:example, attr: :string, other: :integer) do
         attr_accessible :attr, :other
         validates_uniqueness_of :attr, options
       end
@@ -53,26 +63,26 @@ 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').
+      validating_uniqueness_with_existing_record(message: 'Bad value').
         should_not matcher
     end
 
     it 'rejects when the messages do not match' do
-      validating_uniqueness_with_existing_record(:message => 'Bad value').
+      validating_uniqueness_with_existing_record(message: 'Bad value').
         should_not matcher.with_message(/abc/)
     end
 
     it 'accepts when the messages match' do
-      validating_uniqueness_with_existing_record(:message => 'Bad value').
+      validating_uniqueness_with_existing_record(message: 'Bad value').
         should matcher.with_message(/Bad/)
     end
 
     def validating_uniqueness_with_existing_record(options = {})
-      model = define_model(:example, :attr => :string) do
+      model = define_model(:example, attr: :string) do
         attr_accessible :attr
         validates_uniqueness_of :attr, options
       end.new
-      Example.create!(:attr => 'value')
+      Example.create!(attr: 'value')
       model
     end
   end
@@ -114,27 +124,27 @@ describe Shoulda::Matchers::ActiveModel::ValidateUniquenessOfMatcher do
 
     context 'when the scoped attribute is a date' do
       it "accepts" do
-        validating_scoped_uniqueness([:scope1], :date, :scope1 => Date.today).
+        validating_scoped_uniqueness([:scope1], :date, scope1: Date.today).
           should 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).
+          validating_scoped_uniqueness_with_conflicting_next(:scope1, :date, scope1: Date.today).
             should 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).
+          validating_scoped_uniqueness([:scope1, :scope2], :date, scope1: Date.today, scope2: Date.today).
             should_not 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).
+          validating_scoped_uniqueness([:scope1, :scope2], :date, scope1: Date.today, scope2: Date.today).
             should_not matcher.scoped_to(:scope1)
         end
       end
@@ -142,34 +152,34 @@ describe Shoulda::Matchers::ActiveModel::ValidateUniquenessOfMatcher do
 
     context 'when the scoped attribute is a datetime' do
       it 'accepts' do
-        validating_scoped_uniqueness([:scope1], :datetime, :scope1 => DateTime.now).
+        validating_scoped_uniqueness([:scope1], :datetime, scope1: DateTime.now).
           should 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).
+          validating_scoped_uniqueness_with_conflicting_next(:scope1, :datetime, scope1: DateTime.now).
             should matcher.scoped_to(:scope1)
         end
       end
 
       context 'with a nil value' do
         it 'accepts' do
-          validating_scoped_uniqueness([:scope1], :datetime, :scope1 => nil).
+          validating_scoped_uniqueness([:scope1], :datetime, scope1: nil).
             should 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).
+          validating_scoped_uniqueness([:scope1, :scope2], :datetime, scope1: DateTime.now, scope2: DateTime.now).
             should_not 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).
+          validating_scoped_uniqueness([:scope1, :scope2], :datetime, scope1: DateTime.now, scope2: DateTime.now).
             should_not matcher.scoped_to(:scope1)
         end
       end
@@ -177,20 +187,20 @@ describe Shoulda::Matchers::ActiveModel::ValidateUniquenessOfMatcher do
 
     context 'when the scoped attribute is a uuid' do
       it 'accepts' do
-        validating_scoped_uniqueness([:scope1], :uuid, :scope1 => SecureRandom.uuid).
+        validating_scoped_uniqueness([:scope1], :uuid, scope1: SecureRandom.uuid).
           should 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).
+          validating_scoped_uniqueness_with_conflicting_next(:scope1, :uuid, scope1: SecureRandom.uuid).
             should matcher.scoped_to(:scope1)
         end
       end
 
       context 'with a nil value' do
         it 'accepts' do
-          validating_scoped_uniqueness([:scope1], :uuid, :scope1 => nil).
+          validating_scoped_uniqueness([:scope1], :uuid, scope1: nil).
             should matcher.scoped_to(:scope1)
         end
       end
@@ -198,8 +208,8 @@ describe Shoulda::Matchers::ActiveModel::ValidateUniquenessOfMatcher do
       context 'when too narrow of a scope is specified' do
         it 'rejects' do
           record = validating_scoped_uniqueness([:scope1, :scope2], :uuid,
-            :scope1 => SecureRandom.uuid,
-            :scope2 => SecureRandom.uuid
+            scope1: SecureRandom.uuid,
+            scope2: SecureRandom.uuid
           )
           record.should_not matcher.scoped_to(:scope1, :scope2, :other)
         end
@@ -208,8 +218,8 @@ describe Shoulda::Matchers::ActiveModel::ValidateUniquenessOfMatcher do
       context 'when too broad of a scope is specified' do
         it 'rejects' do
           record = validating_scoped_uniqueness([:scope1, :scope2], :uuid,
-            :scope1 => SecureRandom.uuid,
-            :scope2 => SecureRandom.uuid
+            scope1: SecureRandom.uuid,
+            scope2: SecureRandom.uuid
           )
           record.should_not matcher.scoped_to(:scope1)
         end
@@ -221,15 +231,15 @@ describe Shoulda::Matchers::ActiveModel::ValidateUniquenessOfMatcher do
     end
 
     def create_record(attributes = {})
-      default_attributes = {:attr => 'value', :scope1 => 1, :scope2 => 2, :other => 3}
+      default_attributes = {attr: 'value', scope1: 1, scope2: 2, other: 3}
       Example.create!(default_attributes.merge(attributes))
     end
 
     def define_scoped_model(scope, scope_attr_type = :integer)
-      define_model(:example, :attr => :string, :scope1 => scope_attr_type,
-                   :scope2 => scope_attr_type, :other => :integer) do
+      define_model(:example, attr: :string, scope1: scope_attr_type,
+                   scope2: scope_attr_type, other: :integer) do
         attr_accessible :attr, :scope1, :scope2, :other
-        validates_uniqueness_of :attr, :scope => scope
+        validates_uniqueness_of :attr, scope: scope
       end
     end
 
@@ -278,7 +288,7 @@ describe Shoulda::Matchers::ActiveModel::ValidateUniquenessOfMatcher do
     context "when there is an existing entry with a nil" do
       it "should allow_nil" do
         model = define_model_with_allow_nil
-        Example.create!(:attr => nil)
+        Example.create!(attr: nil)
         model.should matcher.allow_nil
       end
     end
@@ -290,9 +300,9 @@ describe Shoulda::Matchers::ActiveModel::ValidateUniquenessOfMatcher do
     end
 
     def define_model_with_allow_nil
-      define_model(:example, :attr  => :integer) do
+      define_model(:example, attr: :integer) do
         attr_accessible :attr
-        validates_uniqueness_of :attr, :allow_nil => true
+        validates_uniqueness_of :attr, allow_nil: true
       end.new
     end
   end
@@ -301,7 +311,7 @@ describe Shoulda::Matchers::ActiveModel::ValidateUniquenessOfMatcher do
     context "when there is an existing entry with a nil" do
       it "should not allow_nil" do
         model = define_model_without_allow_nil
-        Example.create!(:attr => nil)
+        Example.create!(attr: nil)
         model.should_not matcher.allow_nil
       end
     end
@@ -312,7 +322,7 @@ describe Shoulda::Matchers::ActiveModel::ValidateUniquenessOfMatcher do
     end
 
     def define_model_without_allow_nil
-      define_model(:example, :attr  => :integer) do
+      define_model(:example, attr: :integer) do
         attr_accessible :attr
         validates_uniqueness_of :attr
       end.new
@@ -320,14 +330,14 @@ describe Shoulda::Matchers::ActiveModel::ValidateUniquenessOfMatcher do
   end
 
   def case_sensitive_validation_with_existing_value(attr_type)
-    model = define_model(:example, :attr => attr_type) do
+    model = define_model(:example, attr: attr_type) do
       attr_accessible :attr
-      validates_uniqueness_of :attr, :case_sensitive => true
+      validates_uniqueness_of :attr, case_sensitive: true
     end.new
     if attr_type == :string
-      Example.create!(:attr => 'value')
+      Example.create!(attr: 'value')
     elsif attr_type == :integer
-      Example.create!(:attr => 1)
+      Example.create!(attr: 1)
     else
       raise 'Must be :string or :integer'
     end