shoulda-matchers 3.0.1 → 3.1.0

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

@@ -32,14 +32,42 @@ describe Shoulda::Matchers::ActiveModel::ValidateAbsenceOfMatcher, type: :model
             expect(validating_absence_of(:attr, {}, type: type)).
               to validate_absence_of(:attr)
           end
+
+          it_supports(
+            'ignoring_interference_by_writer',
+            tests: {
+              accept_if_qualified_but_changing_value_does_not_interfere: {
+                changing_values_with: :next_value
+              },
+            }
+          )
+
+          define_method(:validation_matcher_scenario_args) do |*args|
+            super(*args).deep_merge(column_type: type)
+          end
         end
       end
+
+      def validation_matcher_scenario_args
+        super.deep_merge(model_creator: :active_record)
+      end
     end
 
     context 'a model without an absence validation' do
-      it 'rejects' do
-        model = define_model(:example, attr: :string).new
-        expect(model).not_to validate_absence_of(:attr)
+      it 'rejects with the correct failure message' do
+        record = define_model(:example, attr: :string).new
+
+        message = <<-MESSAGE
+Example did not properly validate that :attr is empty/falsy.
+  After setting :attr to ‹"an arbitrary value"›, the matcher expected
+  the Example to be invalid, but it was valid instead.
+        MESSAGE
+
+        assertion = lambda do
+          expect(record).to validate_absence_of(:attr)
+        end
+
+        expect(&assertion).to fail_with_message(message)
       end
     end
 
@@ -51,17 +79,34 @@ describe Shoulda::Matchers::ActiveModel::ValidateAbsenceOfMatcher, type: :model
       it 'does not override the default message with a blank' do
         expect(active_model_validating_absence_of(:attr)).to validate_absence_of(:attr).with_message(nil)
       end
+
+      it_supports(
+        'ignoring_interference_by_writer',
+        tests: {
+          accept_if_qualified_but_changing_value_does_not_interfere: {
+            changing_values_with: :upcase
+          },
+        }
+      )
+
+      def validation_matcher_scenario_args
+        super.deep_merge(model_creator: :active_model)
+      end
     end
 
     context 'an ActiveModel class without an absence validation' do
-      it 'rejects' do
-        expect(active_model_with(:attr)).not_to validate_absence_of(:attr)
-      end
+      it 'rejects with the correct failure message' do
+        message = <<-MESSAGE
+Example did not properly validate that :attr is empty/falsy.
+  After setting :attr to ‹"an arbitrary value"›, the matcher expected
+  the Example to be invalid, but it was valid instead.
+        MESSAGE
 
-      it 'provides the correct failure message' do
-        message = %{Expected errors to include "must be blank" when attr is set to "an arbitrary value",\ngot no errors}
+        assertion = lambda do
+          expect(active_model_with(:attr)).to validate_absence_of(:attr)
+        end
 
-        expect { expect(active_model_with(:attr)).to validate_absence_of(:attr) }.to fail_with_message(message)
+        expect(&assertion).to fail_with_message(message)
       end
     end
 
@@ -69,6 +114,19 @@ describe Shoulda::Matchers::ActiveModel::ValidateAbsenceOfMatcher, type: :model
       it 'requires the attribute to not be set' do
         expect(having_many(:children, absence: true)).to validate_absence_of(:children)
       end
+
+      it_supports(
+        'ignoring_interference_by_writer',
+        tests: {
+          accept_if_qualified_but_changing_value_does_not_interfere: {
+            changing_values_with: :next_value
+          },
+        }
+      )
+
+      def validation_matcher_scenario_args
+        super.deep_merge(model_creator: :"active_record/has_many")
+      end
     end
 
     context 'a has_many association without an absence validation' do
@@ -83,12 +141,36 @@ describe Shoulda::Matchers::ActiveModel::ValidateAbsenceOfMatcher, type: :model
         model = having_and_belonging_to_many(:children, absence: true)
         expect(model).to validate_absence_of(:children)
       end
+
+      it_supports(
+        'ignoring_interference_by_writer',
+        tests: {
+          accept_if_qualified_but_changing_value_does_not_interfere: {
+            changing_values_with: :next_value
+          },
+        }
+      )
+
+      def validation_matcher_scenario_args
+        super.deep_merge(model_creator: :"active_record/habtm")
+      end
     end
 
     context 'a non-absent has_and_belongs_to_many association' do
-      it 'rejects' do
+      it 'rejects with the correct failure message' do
         model = having_and_belonging_to_many(:children, absence: false)
-        expect(model).not_to validate_absence_of(:children)
+
+        message = <<-MESSAGE
+Parent did not properly validate that :children is empty/falsy.
+  After setting :children to ‹[#<Child id: nil>]›, the matcher expected
+  the Parent to be invalid, but it was valid instead.
+        MESSAGE
+
+        assertion = lambda do
+          expect(model).to validate_absence_of(:children)
+        end
+
+        expect(&assertion).to fail_with_message(message)
       end
     end
 
@@ -119,14 +201,28 @@ describe Shoulda::Matchers::ActiveModel::ValidateAbsenceOfMatcher, type: :model
       end
     end
 
-    def validating_absence_of(attr, validation_options = {}, given_column_options = {})
+    def define_model_validating_absence_of(attr, validation_options = {}, given_column_options = {})
       default_column_options = { type: :string, options: {} }
       column_options = default_column_options.merge(given_column_options)
 
-      define_model :example, attr => column_options do
-        validates_absence_of attr, validation_options
-      end.new
+      define_model :example, attr => column_options do |model|
+        model.validates_absence_of(attr, validation_options)
+
+        if block_given?
+          yield model
+        end
+      end
+    end
+
+    def validating_absence_of(attr, validation_options = {}, given_column_options = {})
+      model = define_model_validating_absence_of(
+        attr,
+        validation_options,
+        given_column_options
+      )
+      model.new
     end
+    alias_method :build_record_validating_absence_of, :validating_absence_of
 
     def active_model_with(attr, &block)
       define_active_model_class('Example', accessors: [attr], &block).new
@@ -162,5 +258,9 @@ describe Shoulda::Matchers::ActiveModel::ValidateAbsenceOfMatcher, type: :model
         end
       end.new
     end
+
+    def validation_matcher_scenario_args
+      super.deep_merge(matcher_name: :validate_absence_of)
+    end
   end
 end

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

@@ -9,6 +9,32 @@ describe Shoulda::Matchers::ActiveModel::ValidateAcceptanceOfMatcher, type: :mod
     it 'does not overwrite the default message with nil' do
       expect(record_validating_acceptance).to matcher.with_message(nil)
     end
+
+    it_supports(
+      'ignoring_interference_by_writer',
+      tests: {
+        accept_if_qualified_but_changing_value_does_not_interfere: {
+          changing_values_with: :never_falsy,
+        },
+        reject_if_qualified_but_changing_value_interferes: {
+          model_name: 'Example',
+          attribute_name: :attr,
+          changing_values_with: :always_nil,
+          expected_message: <<-MESSAGE.strip
+Example did not properly validate that :attr has been set to "1".
+  After setting :attr to ‹false› -- which was read back as ‹nil› -- the
+  matcher expected the Example to be invalid, but it was valid instead.
+
+  As indicated in the message above, :attr seems to be changing certain
+  values as they are set, and this could have something to do with why
+  this test is failing. If you've overridden the writer method for this
+  attribute, then you may need to change it to make this test pass, or
+  do something else entirely.
+          MESSAGE
+        },
+      },
+      model_creator: :active_model
+    )
   end
 
   context 'a model without an acceptance validation' do
@@ -33,8 +59,9 @@ describe Shoulda::Matchers::ActiveModel::ValidateAcceptanceOfMatcher, type: :mod
     validate_acceptance_of(:attr)
   end
 
-  def model_validating_nothing(&block)
-    define_active_model_class(:example, accessors: [:attr], &block)
+  def model_validating_nothing(options = {}, &block)
+    attribute_name = options.fetch(:attribute_name, :attr)
+    define_active_model_class(:example, accessors: [attribute_name], &block)
   end
 
   def record_validating_nothing
@@ -42,12 +69,23 @@ describe Shoulda::Matchers::ActiveModel::ValidateAcceptanceOfMatcher, type: :mod
   end
 
   def model_validating_acceptance(options = {})
-    model_validating_nothing do
-      validates_acceptance_of :attr, options
+    attribute_name = options.fetch(:attribute_name, :attr)
+
+    model_validating_nothing(attribute_name: attribute_name) do
+      validates_acceptance_of attribute_name, options
     end
   end
 
+  alias_method :define_model_validating_acceptance, :model_validating_acceptance
+
   def record_validating_acceptance(options = {})
     model_validating_acceptance(options).new
   end
+
+  alias_method :build_record_validating_acceptance,
+    :record_validating_acceptance
+
+  def validation_matcher_scenario_args
+    { matcher_name: :validate_acceptance_of }
+  end
 end

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

@@ -6,7 +6,7 @@ describe Shoulda::Matchers::ActiveModel::ValidateConfirmationOfMatcher, type: :m
   context '#description' do
     it 'states that the confirmation must match its base attribute' do
       builder = builder_for_record_validating_confirmation
-      message = "require #{builder.confirmation_attribute} to match #{builder.attribute_to_confirm}"
+      message = "validate that :#{builder.confirmation_attribute} matches :#{builder.attribute_to_confirm}"
       matcher = described_class.new(builder.attribute_to_confirm)
       expect(matcher.description).to eq(message)
     end
@@ -27,13 +27,95 @@ describe Shoulda::Matchers::ActiveModel::ValidateConfirmationOfMatcher, type: :m
           with_message(nil)
       end
     end
+
+    it_supports(
+      'ignoring_interference_by_writer',
+      tests: {
+        reject_if_qualified_but_changing_value_interferes: {
+          model_name: 'Example',
+          attribute_name: :password,
+          changing_values_with: :next_value,
+          expected_message: <<-MESSAGE.strip
+Example did not properly validate that :password_confirmation matches
+:password.
+  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
+  instead, producing these validation errors:
+
+  * password_confirmation: ["doesn't match Password"]
+
+  As indicated in the message above, :password seems to be changing
+  certain values as they are set, and this could have something to do
+  with why this test is failing. If you've overridden the writer method
+  for this attribute, then you may need to change it to make this test
+  pass, or do something else entirely.
+          MESSAGE
+        },
+      },
+      model_creator: :active_model
+    )
+  end
+
+  context 'when the model does not have a confirmation attribute' do
+    it 'raises an AttributeDoesNotExistError' do
+      model = define_model(:example)
+
+      assertion = lambda do
+        expect(model.new).to validate_confirmation_of(:attribute_to_confirm)
+      end
+
+      message = <<-MESSAGE.rstrip
+The matcher attempted to set :attribute_to_confirm_confirmation on the
+Example to "some value", but that attribute does not exist.
+      MESSAGE
+
+      expect(&assertion).to raise_error(
+        Shoulda::Matchers::ActiveModel::AllowValueMatcher::AttributeDoesNotExistError,
+        message
+      )
+    end
+  end
+
+  context 'when the model does not have the attribute under test' do
+    it 'raises an AttributeDoesNotExistError' do
+      model = define_model(:example, attribute_to_confirm_confirmation: :string)
+
+      assertion = lambda do
+        expect(model.new).to validate_confirmation_of(:attribute_to_confirm)
+      end
+
+      message = <<-MESSAGE.rstrip
+The matcher attempted to set :attribute_to_confirm on the Example to
+"different value", but that attribute does not exist.
+      MESSAGE
+
+      expect(&assertion).to raise_error(
+        Shoulda::Matchers::ActiveModel::AllowValueMatcher::AttributeDoesNotExistError,
+        message
+      )
+    end
   end
 
-  context 'when the model does not have a confirmation validation' do
-    it 'fails' do
-      model = define_model(:example, attribute_to_confirm: :string)
-      record = model.new
-      expect(record).not_to validate_confirmation_of(:attribute_to_confirm)
+  context 'when the model has all attributes, but does not have the validation' do
+    it 'fails with an appropriate failure message' do
+      model = define_model(:example, attribute_to_confirm: :string) do
+        attr_accessor :attribute_to_confirm_confirmation
+      end
+
+      assertion = lambda do
+        expect(model.new).to validate_confirmation_of(:attribute_to_confirm)
+      end
+
+      message = <<-MESSAGE
+Example did not properly validate that
+:attribute_to_confirm_confirmation matches :attribute_to_confirm.
+  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.
+      MESSAGE
+
+      expect(&assertion).to fail_with_message(message)
     end
   end
 
@@ -60,4 +142,8 @@ describe Shoulda::Matchers::ActiveModel::ValidateConfirmationOfMatcher, type: :m
         to validate_confirmation_of(builder.attribute_to_confirm)
     end
   end
+
+  def validation_matcher_scenario_args
+    super.deep_merge(matcher_name: :validate_confirmation_of)
+  end
 end

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

@@ -16,6 +16,41 @@ describe Shoulda::Matchers::ActiveModel::ValidateExclusionOfMatcher, type: :mode
       expect(validating_exclusion(in: 2..5)).
         to validate_exclusion_of(:attr).in_range(2..5).with_message(nil)
     end
+
+    it_supports(
+      'ignoring_interference_by_writer',
+      tests: {
+        reject_if_qualified_but_changing_value_interferes: {
+          model_name: 'Example',
+          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›.
+  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:
+
+  * attr: ["is reserved"]
+
+  As indicated in the message above, :attr seems to be changing certain
+  values as they are set, and this could have something to do with why
+  this test is failing. If you've overridden the writer method for this
+  attribute, then you may need to change it to make this test pass, or
+  do something else entirely.
+          MESSAGE
+        },
+      },
+      model_creator: :active_model
+    ) do
+      def validation_matcher_scenario_args
+        super.deep_merge(validation_options: { in: 2..5 })
+      end
+
+      def configure_validation_matcher(matcher)
+        matcher.in_range(2..5)
+      end
+    end
   end
 
   context 'an attribute which must be excluded from a range with excluded end' do
@@ -57,6 +92,14 @@ describe Shoulda::Matchers::ActiveModel::ValidateExclusionOfMatcher, type: :mode
       expect(model).to validate_exclusion_of(:attr).in_range(2...5).
         with_message(/should be out of this range/)
     end
+
+    it 'has correct description' do
+      matcher = validate_exclusion_of(:attr).in_range(1..10)
+
+      expect(matcher.description).to eq(
+        'validate that :attr lies outside the range ‹1› to ‹10›'
+      )
+    end
   end
 
   context 'an attribute which must be excluded from an array' do
@@ -75,21 +118,90 @@ describe Shoulda::Matchers::ActiveModel::ValidateExclusionOfMatcher, type: :mode
         not_to validate_exclusion_of(:attr).in_array(%w(cat dog))
     end
 
-    it 'has correct description' do
-      expect(validate_exclusion_of(:attr).in_array([true, 'dog']).description).
-        to eq 'ensure exclusion of attr in [true, "dog"]'
+    context 'when there is one value' do
+      it 'has correct description' do
+        expect(validate_exclusion_of(:attr).in_array([true]).description).
+          to eq 'validate that :attr is not ‹true›'
+      end
     end
 
-    def validating_exclusion(options)
-      define_model(:example, attr: :string) do
-        validates_exclusion_of :attr, options
-      end.new
+    context 'when there are two values' do
+      it 'has correct description' do
+        matcher = validate_exclusion_of(:attr).in_array([true, 'dog'])
+
+        expect(matcher.description).to eq(
+          'validate that :attr is neither ‹true› nor ‹"dog"›'
+        )
+      end
+    end
+
+    context 'when there are three or more values' do
+      it 'has correct description' do
+        matcher = validate_exclusion_of(:attr).in_array([true, 'dog', 'cat'])
+
+        expect(matcher.description).to eq(
+          'validate that :attr is neither ‹true›, ‹"dog"›, nor ‹"cat"›'
+        )
+      end
+    end
+
+    it_supports(
+      'ignoring_interference_by_writer',
+      tests: {
+        reject_if_qualified_but_changing_value_interferes: {
+          model_name: 'Example',
+          attribute_name: :attr,
+          changing_values_with: :next_value,
+          expected_message: <<-MESSAGE.strip
+Example did not properly validate that :attr is neither ‹"one"› nor
+‹"two"›.
+  After setting :attr to ‹"one"› -- which was read back as ‹"onf"› --
+  the matcher expected the Example to be invalid, but it was valid
+  instead.
+
+  As indicated in the message above, :attr seems to be changing certain
+  values as they are set, and this could have something to do with why
+  this test is failing. If you've overridden the writer method for this
+  attribute, then you may need to change it to make this test pass, or
+  do something else entirely.
+        MESSAGE
+        },
+      },
+      model_creator: :active_model
+    ) do
+      def validation_matcher_scenario_args
+        super.deep_merge(validation_options: { in: ['one', 'two'] })
+      end
+
+      def configure_validation_matcher(matcher)
+        matcher.in_array(['one', 'two'])
+      end
+    end
+
+    def define_model_validating_exclusion(options)
+      options = options.dup
+      column_type = options.delete(:column_type) { :string }
+      super options.merge(column_type: column_type)
+    end
+  end
+
+  def define_model_validating_exclusion(options)
+    options = options.dup
+    attribute_name = options.delete(:attribute_name) { :attr }
+    column_type = options.delete(:column_type) { :integer }
+
+    define_model(:example, attribute_name => column_type) do |model|
+      model.validates_exclusion_of(attribute_name, options)
     end
   end
 
   def validating_exclusion(options)
-    define_model(:example, attr: :integer) do
-      validates_exclusion_of :attr, options
-    end.new
+    define_model_validating_exclusion(options).new
+  end
+
+  alias_method :build_record_validating_exclusion, :validating_exclusion
+
+  def validation_matcher_scenario_args
+    super.deep_merge(matcher_name: :validate_exclusion_of)
   end
 end