shoulda-matchers 3.1.3 → 4.0.0.rc1

data/spec/unit/shoulda/matchers/active_model/allow_value_matcher_spec.rb

@@ -815,16 +815,14 @@ value", but that attribute does not exist.
     end
   end
 
-  if active_record_supports_enum?
-    context 'given an ActiveRecord model' do
-      context 'where the attribute under test is an enum and the given value is a value in that enum' do
-        it 'accepts' do
-          model = define_model('Shipment', status: :integer) do
-            enum status: { pending: 1, shipped: 2, delivered: 3 }
-          end
-
-          expect(model.new).to allow_value(1).for(:status)
+  context 'given an ActiveRecord model' do
+    context 'where the attribute under test is an enum and the given value is a value in that enum' do
+      it 'accepts' do
+        model = define_model('Shipment', status: :integer) do
+          enum status: { pending: 1, shipped: 2, delivered: 3 }
         end
+
+        expect(model.new).to allow_value(1).for(:status)
       end
     end
   end

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

@@ -1,7 +1,7 @@
 require 'unit_spec_helper'
 
 describe Shoulda::Matchers::ActiveModel::ValidateAbsenceOfMatcher, type: :model do
-  if active_model_4_0?
+  if active_model_supports_absence_validation?
     def self.available_column_types
       [
         :string,
@@ -48,6 +48,27 @@ describe Shoulda::Matchers::ActiveModel::ValidateAbsenceOfMatcher, type: :model
         end
       end
 
+      context 'when used in the negative' do
+        it 'fails' do
+          assertion = lambda do
+            expect(validating_absence_of(:attr)).
+              not_to validate_absence_of(:attr)
+          end
+
+          message = <<-MESSAGE
+Expected Example not to validate that :attr is empty/falsy, but this
+could not be proved.
+  After setting :attr to ‹"an arbitrary value"›, the matcher expected
+  the Example to be valid, but it was invalid instead, producing these
+  validation errors:
+
+  * attr: ["must be blank"]
+          MESSAGE
+
+          expect(&assertion).to fail_with_message(message)
+        end
+      end
+
       def validation_matcher_scenario_args
         super.deep_merge(model_creator: :active_record)
       end
@@ -58,7 +79,8 @@ describe Shoulda::Matchers::ActiveModel::ValidateAbsenceOfMatcher, type: :model
         record = define_model(:example, attr: :string).new
 
         message = <<-MESSAGE
-Example did not properly validate that :attr is empty/falsy.
+Expected Example to validate that :attr is empty/falsy, but this could
+not be proved.
   After setting :attr to ‹"an arbitrary value"›, the matcher expected
   the Example to be invalid, but it was valid instead.
         MESSAGE
@@ -97,7 +119,8 @@ Example did not properly validate that :attr is empty/falsy.
     context 'an ActiveModel class without an absence validation' do
       it 'rejects with the correct failure message' do
         message = <<-MESSAGE
-Example did not properly validate that :attr is empty/falsy.
+Expected Example to validate that :attr is empty/falsy, but this could
+not be proved.
   After setting :attr to ‹"an arbitrary value"›, the matcher expected
   the Example to be invalid, but it was valid instead.
         MESSAGE
@@ -161,7 +184,8 @@ Example did not properly validate that :attr is empty/falsy.
         model = having_and_belonging_to_many(:children, absence: false)
 
         message = <<-MESSAGE
-Parent did not properly validate that :children is empty/falsy.
+Expected Parent to validate that :children is empty/falsy, but this
+could not be proved.
   After setting :children to ‹[#<Child id: nil>]›, the matcher expected
   the Parent to be invalid, but it was valid instead.
         MESSAGE

data/spec/unit/shoulda/matchers/active_model/validate_acceptance_of_matcher_spec.rb

@@ -21,7 +21,8 @@ describe Shoulda::Matchers::ActiveModel::ValidateAcceptanceOfMatcher, type: :mod
           attribute_name: :attr,
           changing_values_with: :always_nil,
           expected_message: <<-MESSAGE.strip
-Example did not properly validate that :attr has been set to "1".
+Expected Example to validate that :attr has been set to "1", but this
+could not be proved.
   After setting :attr to ‹false› -- which was read back as ‹nil› -- the
   matcher expected the Example to be invalid, but it was valid instead.
 
@@ -35,6 +36,23 @@ Example did not properly validate that :attr has been set to "1".
       },
       model_creator: :active_model
     )
+
+    it 'fails when used in the negative' do
+      assertion = lambda do
+        expect(record_validating_acceptance).not_to matcher
+      end
+
+      message = <<-MESSAGE
+Expected Example not to validate that :attr has been set to "1", but
+this could not be proved.
+  After setting :attr to ‹false›, the matcher expected the Example to be
+  valid, but it was invalid instead, producing these validation errors:
+
+  * attr: ["must be accepted"]
+      MESSAGE
+
+      expect(&assertion).to fail_with_message(message)
+    end
   end
 
   context 'a model without an acceptance validation' do

data/spec/unit/shoulda/matchers/active_model/validate_confirmation_of_matcher_spec.rb

@@ -36,8 +36,8 @@ describe Shoulda::Matchers::ActiveModel::ValidateConfirmationOfMatcher, type: :m
           attribute_name: :password,
           changing_values_with: :next_value,
           expected_message: <<-MESSAGE.strip
-Example did not properly validate that :password_confirmation matches
-:password.
+Expected Example to validate that :password_confirmation matches
+:password, but this could not be proved.
   After setting :password_confirmation to ‹"same value"›, then setting
   :password to ‹"same value"› -- which was read back as ‹"same valuf"›
   -- the matcher expected the Example to be valid, but it was invalid
@@ -55,6 +55,29 @@ Example did not properly validate that :password_confirmation matches
       },
       model_creator: :active_model
     )
+
+    it 'fails when used in the negative' do
+      builder = builder_for_record_validating_confirmation(
+        model_name: 'Example',
+        attribute: :password,
+        confirmation_attribute: :password_confirmation
+      )
+
+      assertion = lambda do
+        expect(builder.record).
+          not_to validate_confirmation_of(builder.attribute_to_confirm)
+      end
+
+      message = <<-MESSAGE
+Expected Example not to validate that :password_confirmation matches
+:password, but this could not be proved.
+  After setting :password_confirmation to ‹nil›, then setting :password
+  to ‹"any value"›, the matcher expected the Example to be invalid, but
+  it was valid instead.
+      MESSAGE
+
+      expect(&assertion).to fail_with_message(message)
+    end
   end
 
   context 'when the model does not have a confirmation attribute' do
@@ -108,8 +131,8 @@ The matcher attempted to set :attribute_to_confirm on the Example to
       end
 
       message = <<-MESSAGE
-Example did not properly validate that
-:attribute_to_confirm_confirmation matches :attribute_to_confirm.
+Expected Example to validate that :attribute_to_confirm_confirmation
+matches :attribute_to_confirm, but this could not be proved.
   After setting :attribute_to_confirm_confirmation to ‹"some value"›,
   then setting :attribute_to_confirm to ‹"different value"›, the matcher
   expected the Example to be invalid, but it was valid instead.

data/spec/unit/shoulda/matchers/active_model/validate_exclusion_of_matcher_spec.rb

@@ -7,11 +7,26 @@ describe Shoulda::Matchers::ActiveModel::ValidateExclusionOfMatcher, type: :mode
         to validate_exclusion_of(:attr).in_range(2..5)
     end
 
-    it 'rejects ensuring excluded value' do
+    it 'rejects if the given range spills past the top of the range in the validation' do
       expect(validating_exclusion(in: 2..5)).
         not_to validate_exclusion_of(:attr).in_range(2..6)
     end
 
+    it 'rejects if the given range falls short of the top of the range in the validation' do
+      expect(validating_exclusion(in: 2..5)).
+        not_to validate_exclusion_of(:attr).in_range(2..4)
+    end
+
+    it 'rejects if the given range spills past the bottom of the range in the validation' do
+      expect(validating_exclusion(in: 2..5)).
+        not_to validate_exclusion_of(:attr).in_range(1..5)
+    end
+
+    it 'rejects if the given range falls short of the bottom of the range in the validation' do
+      expect(validating_exclusion(in: 2..5)).
+        not_to validate_exclusion_of(:attr).in_range(3..5)
+    end
+
     it 'does not override the default message with a blank' do
       expect(validating_exclusion(in: 2..5)).
         to validate_exclusion_of(:attr).in_range(2..5).with_message(nil)
@@ -25,8 +40,8 @@ describe Shoulda::Matchers::ActiveModel::ValidateExclusionOfMatcher, type: :mode
           attribute_name: :attr,
           changing_values_with: :next_value,
           expected_message: <<-MESSAGE.strip
-Example did not properly validate that :attr lies outside the range ‹2›
-to ‹5›.
+Expected Example to validate that :attr lies outside the range ‹2› to
+‹5›, but this could not be proved.
   After setting :attr to ‹1› -- which was read back as ‹2› -- the
   matcher expected the Example to be valid, but it was invalid instead,
   producing these validation errors:
@@ -51,6 +66,22 @@ to ‹5›.
         matcher.in_range(2..5)
       end
     end
+
+    it 'fails when used in the negative' do
+      assertion = lambda do
+        expect(validating_exclusion(in: 2..5)).
+          not_to validate_exclusion_of(:attr).in_range(2..5)
+      end
+
+      message = <<-MESSAGE
+Expected Example not to validate that :attr lies outside the range ‹2›
+to ‹5›, but this could not be proved.
+  After setting :attr to ‹6›, the matcher expected the Example to be
+  invalid, but it was valid instead.
+      MESSAGE
+
+      expect(&assertion).to fail_with_message(message)
+    end
   end
 
   context 'an attribute which must be excluded from a range with excluded end' do
@@ -70,6 +101,14 @@ to ‹5›.
       expect(validating_exclusion(in: 2..4, message: 'not good')).
         to validate_exclusion_of(:attr).in_range(2..4).with_message(/not good/)
     end
+
+    it 'accepts ensuring the correct range with an interpolated variable in the message' do
+      matcher = validating_exclusion(in: 2..4, message: '%{value} is not good')
+      expect(matcher).
+      to validate_exclusion_of(:attr).
+        in_range(2..4).
+        with_message(/^[234] is not good$/)
+    end
   end
 
   context 'an attribute with custom range validations' do
@@ -153,8 +192,8 @@ to ‹5›.
           attribute_name: :attr,
           changing_values_with: :next_value,
           expected_message: <<-MESSAGE.strip
-Example did not properly validate that :attr is neither ‹"one"› nor
-‹"two"›.
+Expected Example to validate that :attr is neither ‹"one"› nor ‹"two"›,
+but this could not be proved.
   After setting :attr to ‹"one"› -- which was read back as ‹"onf"› --
   the matcher expected the Example to be invalid, but it was valid
   instead.
@@ -178,6 +217,24 @@ Example did not properly validate that :attr is neither ‹"one"› nor
       end
     end
 
+    it 'fails when used in the negative' do
+      assertion = lambda do
+        expect(validating_exclusion(in: %w(one two))).
+          not_to validate_exclusion_of(:attr).in_array(%w(one two))
+      end
+
+      message = <<-MESSAGE
+Expected Example not to validate that :attr is neither ‹"one"› nor
+‹"two"›, but this could not be proved.
+  After setting :attr to ‹"two"›, the matcher expected the Example to be
+  valid, but it was invalid instead, producing these validation errors:
+
+  * attr: ["is reserved"]
+      MESSAGE
+
+      expect(&assertion).to fail_with_message(message)
+    end
+
     def define_model_validating_exclusion(options)
       options = options.dup
       column_type = options.delete(:column_type) { :string }

data/spec/unit/shoulda/matchers/active_model/validate_inclusion_of_matcher_spec.rb

@@ -25,7 +25,7 @@ describe Shoulda::Matchers::ActiveModel::ValidateInclusionOfMatcher, type: :mode
       it_behaves_like 'it supports in_array',
         possible_values: (1..5).to_a,
         zero: 0,
-        reserved_outside_value: described_class::ARBITRARY_OUTSIDE_FIXNUM
+        reserved_outside_value: described_class::ARBITRARY_OUTSIDE_INTEGER
 
       it_behaves_like 'it supports in_range',
         possible_values: 1..5,
@@ -82,7 +82,7 @@ describe Shoulda::Matchers::ActiveModel::ValidateInclusionOfMatcher, type: :mode
       it_behaves_like 'it supports in_array',
         possible_values: [1.0, 2.0, 3.0, 4.0, 5.0],
         zero: 0.0,
-        reserved_outside_value: described_class::ARBITRARY_OUTSIDE_FIXNUM
+        reserved_outside_value: described_class::ARBITRARY_OUTSIDE_INTEGER
 
       it_behaves_like 'it supports in_range',
         possible_values: 1.0..5.0,
@@ -192,20 +192,19 @@ describe Shoulda::Matchers::ActiveModel::ValidateInclusionOfMatcher, type: :mode
     end
 
     context 'against a time attribute' do
-      now = Time.now
+      default_time = Time.zone.local(2000, 1, 1)
 
-      define_method(:now) { now }
+      define_method(:default_time) { default_time }
 
       it_behaves_like 'it supports in_array',
-        possible_values: (1..5).map { |n| now + n },
-        reserved_outside_value: described_class::ARBITRARY_OUTSIDE_TIME
+        possible_values: (1..3).map { |hour| default_time.change(hour: hour) }
 
       it_behaves_like 'it supports in_range',
-        possible_values: (now .. now + 5)
+        possible_values: (default_time.change(hour: 1) .. default_time.change(hour: 3))
 
       define_method :build_object do |options = {}, &block|
         build_object_with_generic_attribute(
-          options.merge(column_type: :time, value: now),
+          options.merge(column_type: :time, value: default_time),
           &block
         )
       end
@@ -215,7 +214,7 @@ describe Shoulda::Matchers::ActiveModel::ValidateInclusionOfMatcher, type: :mode
       end
 
       def validation_matcher_scenario_args
-        super.deep_merge(column_type: :time, default_value: now)
+        super.deep_merge(column_type: :time, default_value: default_time)
       end
     end
 
@@ -368,6 +367,17 @@ describe Shoulda::Matchers::ActiveModel::ValidateInclusionOfMatcher, type: :mode
         end
       end
 
+      it 'matches when validation uses given message that has an interpolated variable' do
+        builder = build_object_allowing(
+          valid_values,
+          validation_options: { message: '%{value} is not included' },
+        )
+
+        expect_to_match_on_values(builder, valid_values) do |matcher|
+          matcher.with_message(/ is not included\Z/)
+        end
+      end
+
       it 'does not match when validation uses the default message instead of given message' do
         builder = build_object_allowing(valid_values)
 
@@ -434,13 +444,25 @@ describe Shoulda::Matchers::ActiveModel::ValidateInclusionOfMatcher, type: :mode
   shared_examples_for 'it supports in_array' do |args|
     possible_values = args.fetch(:possible_values)
     zero = args[:zero]
-    reserved_outside_value = args.fetch(:reserved_outside_value)
+    reserved_outside_value = args[:reserved_outside_value]
 
     define_method(:valid_values) { args.fetch(:possible_values) }
 
-    it 'does not match a record with no validations' do
-      builder = build_object
-      expect_not_to_match_on_values(builder, possible_values)
+    context 'when the record has no validations' do
+      it 'passes when used in the negative' do
+        builder = build_object
+        expect_not_to_match_on_values(builder, possible_values)
+      end
+
+      it 'fails when used in the positive with an appropriate failure message' do
+        builder = build_object
+
+        assertion = lambda do
+          expect_to_match_on_values(builder, possible_values)
+        end
+
+        expect(&assertion).to fail
+      end
     end
 
     it 'matches given the same array of valid values' do
@@ -466,12 +488,24 @@ describe Shoulda::Matchers::ActiveModel::ValidateInclusionOfMatcher, type: :mode
       expect_not_to_match_on_values(builder, add_outside_value_to(possible_values))
     end
 
-    it 'raises an error when valid and given value is our test outside value' do
-      error_class = Shoulda::Matchers::ActiveModel::CouldNotDetermineValueOutsideOfArray
-      builder = build_object_allowing([reserved_outside_value])
+    if reserved_outside_value
+      it 'raises an error when valid and given value is our test outside value' do
+        error_class = Shoulda::Matchers::ActiveModel::CouldNotDetermineValueOutsideOfArray
+        builder = build_object_allowing([reserved_outside_value])
+
+        expect { expect_to_match_on_values(builder, [reserved_outside_value]) }.
+          to raise_error(error_class)
+      end
+    end
+
+    it 'fails when used in the negative' do
+      builder = build_object_allowing(possible_values)
+
+      assertion = lambda do
+        expect_not_to_match_on_values(builder, possible_values)
+      end
 
-      expect { expect_to_match_on_values(builder, [reserved_outside_value]) }.
-        to raise_error(error_class)
+      expect(&assertion).to fail
     end
 
     it_behaves_like 'it supports allow_nil', valid_values: possible_values

data/spec/unit/shoulda/matchers/active_model/validate_length_of_matcher_spec.rb

@@ -33,8 +33,8 @@ describe Shoulda::Matchers::ActiveModel::ValidateLengthOfMatcher, type: :model d
           attribute_name: :attr,
           changing_values_with: :add_character,
           expected_message: <<-MESSAGE.strip
-Example did not properly validate that the length of :attr is at least
-4.
+Expected Example to validate that the length of :attr is at least 4, but
+this could not be proved.
   After setting :attr to ‹"xxx"› -- which was read back as ‹"xxxa"› --
   the matcher expected the Example to be invalid, but it was valid
   instead.
@@ -56,6 +56,22 @@ Example did not properly validate that the length of :attr is at least
         matcher.is_at_least(4)
       end
     end
+
+    it 'fails when used in the negative' do
+      assertion = lambda do
+        expect(validating_length(minimum: 4)).
+          not_to validate_length_of(:attr).is_at_least(4)
+      end
+
+      message = <<-MESSAGE
+Expected Example not to validate that the length of :attr is at least 4,
+but this could not be proved.
+  After setting :attr to ‹"xxxx"›, the matcher expected the Example to
+  be invalid, but it was valid instead.
+      MESSAGE
+
+      expect(&assertion).to fail_with_message(message)
+    end
   end
 
   context 'an attribute with a minimum length validation of 0' do
@@ -97,7 +113,8 @@ Example did not properly validate that the length of :attr is at least
           attribute_name: :attr,
           changing_values_with: :remove_character,
           expected_message: <<-MESSAGE.strip
-Example did not properly validate that the length of :attr is at most 4.
+Expected Example to validate that the length of :attr is at most 4, but
+this could not be proved.
   After setting :attr to ‹"xxxxx"› -- which was read back as ‹"xxxx"› --
   the matcher expected the Example to be invalid, but it was valid
   instead.
@@ -153,7 +170,8 @@ Example did not properly validate that the length of :attr is at most 4.
           attribute_name: :attr,
           changing_values_with: :add_character,
           expected_message: <<-MESSAGE.strip
-Example did not properly validate that the length of :attr is 4.
+Expected Example to validate that the length of :attr is 4, but this
+could not be proved.
   After setting :attr to ‹"xxx"› -- which was read back as ‹"xxxa"› --
   the matcher expected the Example to be invalid, but it was valid
   instead.
@@ -264,6 +282,35 @@ Example did not properly validate that the length of :attr is 4.
     end
   end
 
+  context 'qualified with allow_nil' do
+    context 'and validating with allow_nil' do
+      it 'accepts' do
+        expect(validating_length(minimum: 1, allow_nil: true)).
+          to validate_length_of(:attr).is_at_least(1).allow_nil
+      end
+    end
+
+    context 'and not validating with allow_nil' do
+      it 'rejects' do
+        assertion = lambda do
+          expect(validating_length(minimum: 1)).
+            to validate_length_of(:attr).is_at_least(1).allow_nil
+        end
+
+        message = <<-MESSAGE
+Expected Example to validate that the length of :attr is at least 1, but
+this could not be proved.
+  After setting :attr to ‹nil›, the matcher expected the Example to be
+  valid, but it was invalid instead, producing these validation errors:
+
+  * attr: ["is too short (minimum is 1 character)"]
+        MESSAGE
+
+        expect(&assertion).to fail_with_message(message)
+      end
+    end
+  end
+
   def define_model_validating_length(options = {})
     options = options.dup
     attribute_name = options.delete(:attribute_name) { :attr }