shoulda-matchers 3.0.1 → 3.1.0

data/spec/support/unit/validation_matcher_scenario.rb

@@ -0,0 +1,62 @@
+require 'forwardable'
+
+module UnitTests
+  class ValidationMatcherScenario
+    extend Forwardable
+
+    attr_reader :matcher
+
+    def initialize(arguments)
+      @arguments = arguments.dup
+      @matcher_proc = @arguments.delete(:matcher_proc)
+
+      @specified_model_creator = @arguments.delete(:model_creator) do
+        raise KeyError.new(<<-MESSAGE)
+:model_creator is missing. You can either provide it as an option or as
+a method.
+        MESSAGE
+      end
+
+      @model_creator = model_creator_class.new(@arguments)
+    end
+
+    def record
+      @_record ||= model.new.tap do |record|
+        attribute_default_values_by_name.each do |attribute_name, default_value|
+          record.public_send("#{attribute_name}=", default_value)
+        end
+      end
+    end
+
+    def model
+      @_model ||= model_creator.call
+    end
+
+    def matcher
+      @_matcher ||= matcher_proc.call(attribute_name)
+    end
+
+    protected
+
+    attr_reader(
+      :arguments,
+      :existing_value,
+      :matcher_proc,
+      :model_creator,
+      :specified_model_creator,
+    )
+
+    private
+
+    def_delegators(
+      :model_creator,
+      :attribute_name,
+      :attribute_default_values_by_name,
+    )
+
+    def model_creator_class
+      UnitTests::ModelCreators.retrieve(specified_model_creator) ||
+        specified_model_creator
+    end
+  end
+end

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

@@ -108,4 +108,8 @@ describe Shoulda::Matchers::ActiveModel::AllowMassAssignmentOfMatcher, type: :mo
       end
     end
   end
+
+  def define_model(name, columns, &block)
+    super(name, columns, whitelist_attributes: false, &block)
+  end
 end

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

@@ -13,21 +13,24 @@ describe Shoulda::Matchers::ActiveModel::AllowValueMatcher, type: :model do
     it 'describes itself with multiple values' do
       matcher = allow_value('foo', 'bar').for(:baz)
 
-      expect(matcher.description).to eq 'allow baz to be set to any of ["foo", "bar"]'
+      expect(matcher.description).to eq(
+        'allow :baz to be ‹"foo"› or ‹"bar"›'
+      )
     end
 
     it 'describes itself with a single value' do
       matcher = allow_value('foo').for(:baz)
 
-      expect(matcher.description).to eq 'allow baz to be set to "foo"'
+      expect(matcher.description).to eq 'allow :baz to be ‹"foo"›'
     end
 
     if active_model_3_2?
       it 'describes itself with a strict validation' do
         strict_matcher = allow_value('xyz').for(:attr).strict
 
-        expect(strict_matcher.description).
-          to eq %q(doesn't raise when attr is set to "xyz")
+        expect(strict_matcher.description).to eq(
+          'allow :attr to be ‹"xyz"›, raising a validation exception on failure'
+        )
       end
     end
   end
@@ -47,24 +50,192 @@ describe Shoulda::Matchers::ActiveModel::AllowValueMatcher, type: :model do
   end
 
   context 'an attribute with a validation' do
-    it 'allows a good value' do
-      expect(validating_format(with: /abc/)).to allow_value('abcde').for(:attr)
+    context 'given one good value' do
+      context 'when used in the positive' do
+        it 'accepts' do
+          expect(validating_format(with: /abc/)).
+            to allow_value('abcde').for(:attr)
+        end
+      end
+
+      context 'when used in the negative' do
+        it 'rejects with an appropriate failure message' do
+          assertion = lambda do
+            expect(validating_format(with: /abc/)).
+              not_to allow_value('abcde').for(:attr)
+          end
+
+          message = <<-MESSAGE
+After setting :attr to ‹"abcde"›, the matcher expected the Example to be
+invalid, but it was valid instead.
+          MESSAGE
+
+          expect(&assertion).to fail_with_message(message)
+        end
+      end
+    end
+
+    context 'given several good values' do
+      context 'when used in the positive' do
+        it 'accepts' do
+          expect(validating_format(with: /abc/)).
+            to allow_value('abcde', 'deabc').for(:attr)
+        end
+      end
+
+      context 'when used in the negative' do
+        it 'rejects with an appropriate failure message' do
+          assertion = lambda do
+            expect(validating_format(with: /abc/)).
+              not_to allow_value('abcde', 'deabc').for(:attr)
+          end
+
+          message = <<-MESSAGE
+After setting :attr to ‹"abcde"›, the matcher expected the Example to be
+invalid, but it was valid instead.
+          MESSAGE
+
+          expect(&assertion).to fail_with_message(message)
+        end
+      end
     end
 
-    it 'rejects a bad value' do
-      expect(validating_format(with: /abc/)).not_to allow_value('xyz').for(:attr)
+    context 'given one bad value' do
+      context 'when used in the positive' do
+        it 'rejects with an appropriate failure message' do
+          assertion = lambda do
+            expect(validating_format(with: /abc/)).
+              to allow_value('xyz').for(:attr)
+          end
+
+          message = <<-MESSAGE
+After setting :attr to ‹"xyz"›, the matcher expected the Example to be
+valid, but it was invalid instead, producing these validation errors:
+
+* attr: ["is invalid"]
+          MESSAGE
+
+          expect(&assertion).to fail_with_message(message)
+        end
+      end
+
+      context 'when used in the negative' do
+        it 'accepts' do
+          expect(validating_format(with: /abc/)).
+            not_to allow_value('xyz').for(:attr)
+        end
+      end
     end
 
-    it 'allows several good values' do
-      expect(validating_format(with: /abc/)).
-        to allow_value('abcde', 'deabc').for(:attr)
+    context 'given several bad values' do
+      context 'when used in the positive' do
+        it 'rejects with an appropriate failure message' do
+          assertion = lambda do
+            expect(validating_format(with: /abc/)).
+              to allow_value('xyz', 'zyx', nil, []).
+              for(:attr).
+              ignoring_interference_by_writer
+          end
+
+          message = <<-MESSAGE
+After setting :attr to ‹"xyz"›, the matcher expected the Example to be
+valid, but it was invalid instead, producing these validation errors:
+
+* attr: ["is invalid"]
+          MESSAGE
+
+          expect(&assertion).to fail_with_message(message)
+        end
+      end
+
+      context 'when used in the negative' do
+        it 'accepts' do
+          expect(validating_format(with: /abc/)).
+            not_to allow_value('xyz', 'zyx', nil, []).
+            for(:attr).
+            ignoring_interference_by_writer
+        end
+      end
     end
 
-    it 'rejects several bad values' do
-      expect(validating_format(with: /abc/)).
-        not_to allow_value('xyz', 'zyx', nil, []).
-        for(:attr).
-        ignoring_interference_by_writer
+    context 'given good values along with bad values' do
+      context 'when used in the positive' do
+        it 'rejects with an appropriate failure message' do
+          assertion = lambda do
+            expect(validating_format(with: /abc/)).
+              to allow_value('abc', 'xyz').
+              for(:attr).
+              ignoring_interference_by_writer
+          end
+
+          message = <<-MESSAGE
+After setting :attr to ‹"xyz"›, the matcher expected the Example to be
+valid, but it was invalid instead, producing these validation errors:
+
+* attr: ["is invalid"]
+          MESSAGE
+
+          expect(&assertion).to fail_with_message(message)
+        end
+      end
+
+      context 'when used in the negative' do
+        it 'rejects with an appropriate failure message' do
+          assertion = lambda do
+            expect(validating_format(with: /abc/)).
+              not_to allow_value('abc', 'xyz').
+              for(:attr).
+              ignoring_interference_by_writer
+          end
+
+          message = <<-MESSAGE
+After setting :attr to ‹"abc"›, the matcher expected the Example to be
+invalid, but it was valid instead.
+          MESSAGE
+
+          expect(&assertion).to fail_with_message(message)
+        end
+      end
+    end
+
+    context 'given bad values along with good values' do
+      context 'when used in the positive' do
+        it 'rejects with an appropriate failure message' do
+          assertion = lambda do
+            expect(validating_format(with: /abc/)).
+              to allow_value('xyz', 'abc').
+              for(:attr).
+              ignoring_interference_by_writer
+          end
+
+          message = <<-MESSAGE
+After setting :attr to ‹"xyz"›, the matcher expected the Example to be
+valid, but it was invalid instead, producing these validation errors:
+
+* attr: ["is invalid"]
+          MESSAGE
+
+          expect(&assertion).to fail_with_message(message)
+        end
+      end
+
+      context 'when used in the negative' do
+        it 'rejects with an appropriate failure message' do
+          assertion = lambda do
+            expect(validating_format(with: /abc/)).
+              not_to allow_value('xyz', 'abc').
+              for(:attr).
+              ignoring_interference_by_writer
+          end
+
+          message = <<-MESSAGE
+After setting :attr to ‹"abc"›, the matcher expected the Example to be
+invalid, but it was valid instead.
+          MESSAGE
+
+          expect(&assertion).to fail_with_message(message)
+        end
+      end
     end
   end
 
@@ -74,27 +245,95 @@ describe Shoulda::Matchers::ActiveModel::AllowValueMatcher, type: :model do
         to allow_value('abcde').for(:attr).with_message(/bad/)
     end
 
-    it 'rejects a bad value' do
-      expect(validating_format(with: /abc/, message: 'bad value')).
-        not_to allow_value('xyz').for(:attr).with_message(/bad/)
+    it 'rejects a bad value with an appropriate failure message' do
+      message = <<-MESSAGE
+After setting :attr to ‹"xyz"›, the matcher expected the Example to be
+valid, but it was invalid instead, producing these validation errors:
+
+* attr: ["bad value"]
+      MESSAGE
+
+      assertion = lambda do
+        expect(validating_format(with: /abc/, message: 'bad value')).
+          to allow_value('xyz').for(:attr).with_message(/bad/)
+      end
+
+      expect(&assertion).to fail_with_message(message)
     end
 
-    it 'allows interpolation values for the message to be provided' do
-      options = {
-        attribute_name: :attr,
-        attribute_type: :string
-      }
+    context 'when the custom messages do not match' do
+      it 'rejects with an appropriate failure message' do
+        message = <<-MESSAGE
+After setting :attr to ‹"xyz"›, the matcher expected the Example to be
+invalid and to produce a validation error matching ‹/different/› on
+:attr. The record was indeed invalid, but it produced these validation
+errors instead:
+
+* attr: ["bad value"]
+        MESSAGE
 
-      record = record_with_custom_validation(options) do
-        if self.attr == 'xyz'
-          self.errors.add :attr, :greater_than, count: 2
+        assertion = lambda do
+          expect(validating_format(with: /abc/, message: 'bad value')).
+            not_to allow_value('xyz').for(:attr).with_message(/different/)
         end
+
+        expect(&assertion).to fail_with_message(message)
       end
+    end
 
-      expect(record).
-        not_to allow_value('xyz').
-        for(:attr).
-        with_message(:greater_than, values: { count: 2 })
+    context 'when interpolation values are provided along with a custom message' do
+      context 'when the messages match' do
+        it 'accepts' do
+          options = {
+            attribute_name: :attr,
+            attribute_type: :string
+          }
+
+          record = record_with_custom_validation(options) do
+            if self.attr == 'xyz'
+              self.errors.add :attr, :greater_than, count: 2
+            end
+          end
+
+          expect(record).
+            not_to allow_value('xyz').
+            for(:attr).
+            with_message(:greater_than, values: { count: 2 })
+        end
+      end
+
+      context 'when the messages do not match' do
+        it 'rejects with an appropriate failure message' do
+          options = {
+            attribute_name: :attr,
+            attribute_type: :string
+          }
+
+          record = record_with_custom_validation(options) do
+            if self.attr == 'xyz'
+              self.errors.add :attr, "some other error"
+            end
+          end
+
+          assertion = lambda do
+            expect(record).
+              not_to allow_value('xyz').
+              for(:attr).
+              with_message(:greater_than, values: { count: 2 })
+          end
+
+          message = <<-MESSAGE
+After setting :attr to ‹"xyz"›, the matcher expected the Example to be
+invalid and to produce the validation error "must be greater than 2" on
+:attr. The record was indeed invalid, but it produced these validation
+errors instead:
+
+* attr: ["some other error"]
+          MESSAGE
+
+          expect(&assertion).to fail_with_message(message)
+        end
+      end
     end
   end
 
@@ -102,25 +341,62 @@ describe Shoulda::Matchers::ActiveModel::AllowValueMatcher, type: :model do
     include UnitTests::AllowValueMatcherHelpers
 
     context 'when the validation error message was provided directly' do
-      it 'passes given a valid value' do
-        builder = builder_for_record_with_different_error_attribute
-        expect(builder.record).
-          to allow_value(builder.valid_value).
-          for(builder.attribute_to_validate).
-          with_message(builder.message,
-            against: builder.attribute_that_receives_error
-          )
+      context 'given a valid value' do
+        it 'accepts' do
+          builder = builder_for_record_with_different_error_attribute
+          expect(builder.record).
+            to allow_value(builder.valid_value).
+            for(builder.attribute_to_validate).
+            with_message(
+              builder.message,
+              against: builder.attribute_that_receives_error
+            )
+        end
       end
 
-      it 'fails given an invalid value' do
-        builder = builder_for_record_with_different_error_attribute
-        invalid_value = "#{builder.valid_value} (invalid)"
-        expect(builder.record).
-          not_to allow_value(invalid_value).
-          for(builder.attribute_to_validate).
-          with_message(builder.message,
-            against: builder.attribute_that_receives_error
-          )
+      context 'given an invalid value' do
+        it 'rejects' do
+          builder = builder_for_record_with_different_error_attribute
+          invalid_value = "#{builder.valid_value} (invalid)"
+
+          expect(builder.record).
+            not_to allow_value(invalid_value).
+            for(builder.attribute_to_validate).
+            with_message(
+              builder.message,
+              against: builder.attribute_that_receives_error
+            )
+        end
+
+        context 'if the messages do not match' do
+          it 'technically accepts' do
+            builder = builder_for_record_with_different_error_attribute(
+              message: "a different error"
+            )
+            invalid_value = "#{builder.valid_value} (invalid)"
+
+            assertion = lambda do
+              expect(builder.record).
+                not_to allow_value(invalid_value).
+                for(builder.attribute_to_validate).
+                with_message(
+                  "some error",
+                  against: builder.attribute_that_receives_error
+                )
+            end
+
+            message = <<-MESSAGE
+After setting :#{builder.attribute_to_validate} to ‹"#{invalid_value}"›, the
+matcher expected the #{builder.model.name} to be invalid and to produce the validation
+error "some error" on :#{builder.attribute_that_receives_error}. The record was
+indeed invalid, but it produced these validation errors instead:
+
+* #{builder.attribute_that_receives_error}: ["a different error"]
+            MESSAGE
+
+            expect(&assertion).to fail_with_message(message)
+          end
+        end
       end
     end
 
@@ -130,7 +406,8 @@ describe Shoulda::Matchers::ActiveModel::AllowValueMatcher, type: :model do
         expect(builder.record).
           to allow_value(builder.valid_value).
           for(builder.attribute_to_validate).
-          with_message(builder.validation_message_key,
+          with_message(
+            builder.validation_message_key,
             against: builder.attribute_that_receives_error
           )
       end
@@ -141,7 +418,8 @@ describe Shoulda::Matchers::ActiveModel::AllowValueMatcher, type: :model do
         expect(builder.record).
           not_to allow_value(invalid_value).
           for(builder.attribute_to_validate).
-          with_message(builder.validation_message_key,
+          with_message(
+            builder.validation_message_key,
             against: builder.attribute_that_receives_error
           )
       end
@@ -199,11 +477,29 @@ describe Shoulda::Matchers::ActiveModel::AllowValueMatcher, type: :model do
     end
 
     it "does not match given good values along with bad values" do
-      message = %{Expected errors when attr is set to "12345",\ngot no errors}
+      message = <<-MESSAGE.strip_heredoc
+After setting :attr to ‹"12345"›, the matcher expected the Example to be
+invalid, but it was valid instead.
+      MESSAGE
 
-      expect {
+      assertion = lambda do
         expect(model).not_to allow_value('12345', *bad_values).for(:attr)
-      }.to fail_with_message(message)
+      end
+
+      expect(&assertion).to fail_with_message(message)
+    end
+
+    it "does not match given bad values along with good values" do
+      message = <<-MESSAGE.strip_heredoc
+After setting :attr to ‹"12345"›, the matcher expected the Example to be
+invalid, but it was valid instead.
+      MESSAGE
+
+      assertion = lambda do
+        expect(model).not_to allow_value(*bad_values, '12345').for(:attr)
+      end
+
+      expect(&assertion).to fail_with_message(message)
     end
   end
 
@@ -226,161 +522,300 @@ describe Shoulda::Matchers::ActiveModel::AllowValueMatcher, type: :model do
 
   if active_model_3_2?
     context 'an attribute with a strict format validation' do
-      it 'strictly rejects a bad value' do
-        expect(validating_format(with: /abc/, strict: true)).
-          not_to allow_value('xyz').for(:attr).strict
-      end
+      context 'when qualified with strict' do
+        it 'rejects a bad value, providing the correct failure message' do
+          message = <<-MESSAGE.strip_heredoc
+After setting :attr to ‹"xyz"›, the matcher expected the Example to be
+valid, but it was invalid instead, raising a validation exception with
+the message "Attr is invalid".
+          MESSAGE
 
-      it 'strictly allows a bad value with a different message' do
-        expect(validating_format(with: /abc/, strict: true)).
-          to allow_value('xyz').for(:attr).with_message(/abc/).strict
-      end
+          assertion = lambda do
+            expect(validating_format(with: /abc/, strict: true)).
+              to allow_value('xyz').for(:attr).strict
+          end
 
-      it 'provides a useful negative failure message' do
-        matcher = allow_value('xyz').for(:attr).strict.with_message(/abc/)
+          expect(&assertion).to fail_with_message(message)
+        end
 
-        matcher.matches?(validating_format(with: /abc/, strict: true))
+        context 'qualified with a custom message' do
+          it 'rejects a bad value when the failure messages do not match' do
+            message = <<-MESSAGE.strip_heredoc
+After setting :attr to ‹"xyz"›, the matcher expected the Example to be
+invalid and to raise a validation exception with message matching
+‹/abc/›. The record was indeed invalid, but the exception message was
+"Attr is invalid" instead.
+            MESSAGE
+
+            assertion = lambda do
+              expect(validating_format(with: /abc/, strict: true)).
+                not_to allow_value('xyz').for(:attr).with_message(/abc/).strict
+            end
 
-        expect(matcher.failure_message_when_negated).to eq(
-          %{Expected exception to include /abc/ when attr is set to "xyz",\n} +
-          %{got: "Attr is invalid"}
-        )
+            expect(&assertion).to fail_with_message(message)
+          end
+        end
       end
     end
   end
 
   context 'when the attribute interferes with attempts to be set' do
-    context 'when the matcher has not been qualified with #ignoring_interference_by_writer' do
-      context 'when the attribute cannot be changed from nil to non-nil' do
-        it 'raises a CouldNotSetAttributeError' do
-          model = define_active_model_class 'Example' do
-            attr_reader :name
+    context 'when the attribute cannot be changed from nil to non-nil' do
+      context 'and the record remains valid' do
+        it 'accepts (and does not raise an AttributeChangedValueError)' do
+          model = define_active_model_class 'Example', accessors: [:name] do
+            def name=(_value)
+              nil
+            end
+          end
+
+          expect(model.new).to allow_value('anything').for(:name)
+        end
+      end
+
+      context 'and the record becomes invalid' do
+        it 'rejects with an appropriate failure message' do
+          model = define_active_model_class 'Example', accessors: [:name] do
+            validates_presence_of :name
 
             def name=(_value)
               nil
             end
           end
 
-          assertion = -> {
+          assertion = lambda do
             expect(model.new).to allow_value('anything').for(:name)
-          }
+          end
 
-          expect(&assertion).to raise_error(
-            described_class::CouldNotSetAttributeError
-          )
+          message = <<-MESSAGE.strip
+After setting :name to ‹"anything"› -- which was read back as ‹nil› --
+the matcher expected the Example to be valid, but it was invalid
+instead, producing these validation errors:
+
+* name: ["can't be blank"]
+
+As indicated in the message above, :name 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
+
+          expect(&assertion).to fail_with_message(message)
         end
       end
+    end
 
-      context 'when the attribute cannot be changed from non-nil to nil' do
-        it 'raises a CouldNotSetAttribute error' do
-          model = define_active_model_class 'Example' do
-            attr_reader :name
-
+    context 'when the attribute cannot be changed from non-nil to nil' do
+      context 'and the record remains valid' do
+        it 'accepts (and does not raise an AttributeChangedValueError)' do
+          model = define_active_model_class 'Example', accessors: [:name] do
             def name=(value)
-              @name = value unless value.nil?
+              if value
+                super(value)
+              end
             end
           end
 
           record = model.new(name: 'some name')
 
-          assertion = -> {
-            expect(record).to allow_value(nil).for(:name)
-          }
-
-          expect(&assertion).to raise_error(
-            described_class::CouldNotSetAttributeError
-          )
+          expect(record).to allow_value(nil).for(:name)
         end
       end
 
-      context 'when the attribute cannot be changed from a non-nil value to another non-nil value' do
-        it 'raises a CouldNotSetAttribute error' do
-          model = define_active_model_class 'Example' do
-            attr_reader :name
+      context 'and the record becomes invalid' do
+        it 'rejects with an appropriate failure message' do
+          model = define_active_model_class 'Example', accessors: [:name] do
+            validates_absence_of :name
 
-            def name=(_value)
-              @name = 'constant name'
+            def name=(value)
+              if value
+                super(value)
+              end
             end
           end
 
           record = model.new(name: 'some name')
 
-          assertion = -> {
-            expect(record).to allow_value('another name').for(:name)
-          }
+          assertion = lambda do
+            expect(record).to allow_value(nil).for(:name)
+          end
 
-          expect(&assertion).to raise_error(
-            described_class::CouldNotSetAttributeError
-          )
+          message = <<-MESSAGE.strip
+After setting :name to ‹nil› -- which was read back as ‹"some name"› --
+the matcher expected the Example to be valid, but it was invalid
+instead, producing these validation errors:
+
+* name: ["must be blank"]
+
+As indicated in the message above, :name 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
+
+          expect(&assertion).to fail_with_message(message)
         end
       end
     end
 
-    context 'when the matcher has been qualified with #ignoring_interference_by_writer' do
-      context 'when the attribute cannot be changed from nil to non-nil' do
-        it 'does not raise an error at all' do
-          model = define_active_model_class 'Example' do
-            attr_reader :name
-
+    context 'when the attribute cannot be changed from a non-nil value to another non-nil value' do
+      context 'and the record remains valid' do
+        it 'accepts (and does not raise an AttributeChangedValueError)' do
+          model = define_active_model_class 'Example', accessors: [:name] do
             def name=(_value)
-              nil
+              super('constant name')
             end
           end
 
-          assertion = lambda do
-            expect(model.new).
-              to allow_value('anything').
-              for(:name).
-              ignoring_interference_by_writer
-          end
+          record = model.new(name: 'some name')
 
-          expect(&assertion).not_to raise_error
+          expect(record).to allow_value('another name').for(:name)
         end
       end
 
-      context 'when the attribute cannot be changed from non-nil to nil' do
-        it 'does not raise an error at all' do
-          model = define_active_model_class 'Example' do
-            attr_reader :name
+      context 'and the record becomes invalid' do
+        it 'rejects with an appropriate failure message' do
+          model = define_active_model_class 'Example', accessors: [:name] do
+            validates_format_of :name, with: /another name/
 
             def name=(value)
-              @name = value unless value.nil?
+              super('constant name')
             end
           end
 
           record = model.new(name: 'some name')
 
           assertion = lambda do
-            expect(record).
-              to allow_value(nil).
-              for(:name).
-              ignoring_interference_by_writer
+            expect(record).to allow_value('another name').for(:name)
           end
 
-          expect(&assertion).not_to raise_error
+          message = <<-MESSAGE.strip
+After setting :name to ‹"another name"› -- which was read back as
+‹"constant name"› -- the matcher expected the Example to be valid, but
+it was invalid instead, producing these validation errors:
+
+* name: ["is invalid"]
+
+As indicated in the message above, :name 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
+
+          expect(&assertion).to fail_with_message(message)
+        end
+      end
+    end
+  end
+
+  context 'when the attribute does not exist on the model' do
+    context 'when the assertion is positive' do
+      it 'raises an AttributeDoesNotExistError' do
+        model = define_class('Example')
+
+        assertion = lambda do
+          expect(model.new).to allow_value('foo').for(:nonexistent)
         end
+
+        message = <<-MESSAGE.rstrip
+The matcher attempted to set :nonexistent on the Example to "foo", but
+that attribute does not exist.
+        MESSAGE
+
+        expect(&assertion).to raise_error(
+          described_class::AttributeDoesNotExistError,
+          message
+        )
       end
+    end
 
-      context 'when the attribute cannot be changed from a non-nil value to another non-nil value' do
-        it 'does not raise an error at all' do
-          model = define_active_model_class 'Example' do
-            attr_reader :name
+    context 'when the assertion is negative' do
+      it 'raises an AttributeDoesNotExistError' do
+        model = define_class('Example')
 
-            def name=(_value)
-              @name = 'constant name'
-            end
+        assertion = lambda do
+          expect(model.new).not_to allow_value('foo').for(:nonexistent)
+        end
+
+        message = <<-MESSAGE.rstrip
+The matcher attempted to set :nonexistent on the Example to "foo", but
+that attribute does not exist.
+        MESSAGE
+
+        expect(&assertion).to raise_error(
+          described_class::AttributeDoesNotExistError,
+          message
+        )
+      end
+    end
+  end
+
+  context 'given attributes to preset on the record before validation' do
+    context 'when the assertion is positive' do
+      context 'if any attributes do not exist on the model' do
+        it 'raises an AttributeDoesNotExistError' do
+          model = define_active_model_class('Example', accessors: [:existent])
+
+          allow_value_matcher = allow_value('foo').for(:existent).tap do |matcher|
+            matcher.values_to_preset = { nonexistent: 'some value' }
           end
 
-          record = model.new(name: 'some name')
+          assertion = lambda do
+            expect(model.new).to(allow_value_matcher)
+          end
+
+          message = <<-MESSAGE.rstrip
+The matcher attempted to set :nonexistent on the Example to "some
+value", but that attribute does not exist.
+        MESSAGE
+
+          expect(&assertion).to raise_error(
+            described_class::AttributeDoesNotExistError,
+            message
+          )
+        end
+      end
+    end
+
+    context 'when the assertion is negative' do
+      context 'if any attributes do not exist on the model' do
+        it 'raises an AttributeDoesNotExistError' do
+          model = define_active_model_class('Example', accessors: [:existent])
+
+          allow_value_matcher = allow_value('foo').for(:existent).tap do |matcher|
+            matcher.values_to_preset = { nonexistent: 'some value' }
+          end
 
           assertion = lambda do
-            expect(record).
-              to allow_value('another name').
-              for(:name).
-              ignoring_interference_by_writer
+            expect(model.new).not_to(allow_value_matcher)
+          end
+
+          message = <<-MESSAGE.rstrip
+The matcher attempted to set :nonexistent on the Example to "some
+value", but that attribute does not exist.
+        MESSAGE
+
+          expect(&assertion).to raise_error(
+            described_class::AttributeDoesNotExistError,
+            message
+          )
+        end
+      end
+    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(&assertion).not_to raise_error
+          expect(model.new).to allow_value(1).for(:status)
         end
       end
     end