shoulda-matchers 4.0.0.rc1 → 4.0.1

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

@@ -1,335 +0,0 @@
-require 'unit_spec_helper'
-
-describe Shoulda::Matchers::ActiveModel::ValidateLengthOfMatcher, type: :model do
-  context 'an attribute with a non-zero minimum length validation' do
-    it 'accepts ensuring the correct minimum length' do
-      expect(validating_length(minimum: 4)).
-        to validate_length_of(:attr).is_at_least(4)
-    end
-
-    it 'rejects ensuring a lower minimum length with any message' do
-      expect(validating_length(minimum: 4)).
-        not_to validate_length_of(:attr).is_at_least(3).with_short_message(/.*/)
-    end
-
-    it 'rejects ensuring a higher minimum length with any message' do
-      expect(validating_length(minimum: 4)).
-        not_to validate_length_of(:attr).is_at_least(5).with_short_message(/.*/)
-    end
-
-    it 'does not override the default message with a blank' do
-      expect(validating_length(minimum: 4)).
-        to validate_length_of(:attr).is_at_least(4).with_short_message(nil)
-    end
-
-    it_supports(
-      'ignoring_interference_by_writer',
-      tests: {
-        accept_if_qualified_but_changing_value_does_not_interfere: {
-          changing_values_with: :upcase,
-        },
-        reject_if_qualified_but_changing_value_interferes: {
-          model_name: 'Example',
-          attribute_name: :attr,
-          changing_values_with: :add_character,
-          expected_message: <<-MESSAGE.strip
-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.
-
-  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
-        }
-      }
-    ) do
-      def validation_matcher_scenario_args
-        super.deep_merge(validation_options: { minimum: 4 })
-      end
-
-      def configure_validation_matcher(matcher)
-        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
-    it 'accepts ensuring the correct minimum length' do
-      expect(validating_length(minimum: 0)).
-        to validate_length_of(:attr).is_at_least(0)
-    end
-  end
-
-  context 'an attribute with a maximum length' do
-    it 'accepts ensuring the correct maximum length' do
-      expect(validating_length(maximum: 4)).
-        to validate_length_of(:attr).is_at_most(4)
-    end
-
-    it 'rejects ensuring a lower maximum length with any message' do
-      expect(validating_length(maximum: 4)).
-        not_to validate_length_of(:attr).is_at_most(3).with_long_message(/.*/)
-    end
-
-    it 'rejects ensuring a higher maximum length with any message' do
-      expect(validating_length(maximum: 4)).
-        not_to validate_length_of(:attr).is_at_most(5).with_long_message(/.*/)
-    end
-
-    it 'does not override the default message with a blank' do
-      expect(validating_length(maximum: 4)).
-        to validate_length_of(:attr).is_at_most(4).with_long_message(nil)
-    end
-
-    it_supports(
-      'ignoring_interference_by_writer',
-      tests: {
-        accept_if_qualified_but_changing_value_does_not_interfere: {
-          changing_values_with: :upcase,
-        },
-        reject_if_qualified_but_changing_value_interferes: {
-          model_name: 'Example',
-          attribute_name: :attr,
-          changing_values_with: :remove_character,
-          expected_message: <<-MESSAGE.strip
-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.
-
-  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
-        }
-      }
-    ) do
-      def validation_matcher_scenario_args
-        super.deep_merge(validation_options: { maximum: 4 })
-      end
-
-      def configure_validation_matcher(matcher)
-        matcher.is_at_most(4)
-      end
-    end
-  end
-
-  context 'an attribute with a required exact length' do
-    it 'accepts ensuring the correct length' do
-      expect(validating_length(is: 4)).
-        to validate_length_of(:attr).is_equal_to(4)
-    end
-
-    it 'rejects ensuring a lower maximum length with any message' do
-      expect(validating_length(is: 4)).
-        not_to validate_length_of(:attr).is_equal_to(3).with_message(/.*/)
-    end
-
-    it 'rejects ensuring a higher maximum length with any message' do
-      expect(validating_length(is: 4)).
-        not_to validate_length_of(:attr).is_equal_to(5).with_message(/.*/)
-    end
-
-    it 'does not override the default message with a blank' do
-      expect(validating_length(is: 4)).
-        to validate_length_of(:attr).is_equal_to(4).with_message(nil)
-    end
-
-    it_supports(
-      'ignoring_interference_by_writer',
-      tests: {
-        accept_if_qualified_but_changing_value_does_not_interfere: {
-          changing_values_with: :upcase,
-        },
-        reject_if_qualified_but_changing_value_interferes: {
-          model_name: 'Example',
-          attribute_name: :attr,
-          changing_values_with: :add_character,
-          expected_message: <<-MESSAGE.strip
-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.
-
-  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
-        }
-      }
-    ) do
-      def validation_matcher_scenario_args
-        super.deep_merge(validation_options: { is: 4 })
-      end
-
-      def configure_validation_matcher(matcher)
-        matcher.is_equal_to(4)
-      end
-    end
-  end
-
-  context 'an attribute with a required exact length and another validation' do
-    it 'accepts ensuring the correct length' do
-      model = define_model(:example, attr: :string) do
-        validates_length_of :attr, is: 4
-        validates_numericality_of :attr
-      end.new
-
-      expect(model).to validate_length_of(:attr).is_equal_to(4)
-    end
-  end
-
-  context 'an attribute with a custom minimum length validation' do
-    it 'accepts ensuring the correct minimum length' do
-      expect(validating_length(minimum: 4, too_short: 'foobar')).
-        to validate_length_of(:attr).is_at_least(4).with_short_message(/foo/)
-    end
-  end
-
-  context 'an attribute with a custom maximum length validation' do
-    it 'accepts ensuring the correct minimum length' do
-      expect(validating_length(maximum: 4, too_long: 'foobar')).
-        to validate_length_of(:attr).is_at_most(4).with_long_message(/foo/)
-    end
-  end
-
-  context 'an attribute with a custom equal validation' do
-    it 'accepts ensuring the correct exact length' do
-      expect(validating_length(is: 4, message: 'foobar')).
-        to validate_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
-      expect(define_model(:example, attr: :string).new).
-        not_to validate_length_of(:attr).is_at_least(1)
-    end
-  end
-
-  context 'using translations' do
-    after { I18n.backend.reload! }
-
-    context "a too_long translation containing %{attribute}, %{model}" do
-      before do
-        stub_translation(
-          "activerecord.errors.messages.too_long",
-          "The %{attribute} of your %{model} is too long (maximum is %{count} characters)")
-      end
-
-      it "does not raise an exception" do
-        expect {
-          expect(validating_length(maximum: 4)).
-            to validate_length_of(:attr).is_at_most(4)
-        }.to_not raise_exception
-      end
-    end
-
-    context "a too_short translation containing %{attribute}, %{model}" do
-      before do
-        stub_translation(
-          "activerecord.errors.messages.too_short",
-          "The %{attribute} of your %{model} is too short (minimum is %{count} characters)")
-      end
-
-      it "does not raise an exception" do
-        expect {
-          expect(validating_length(minimum: 4)).to validate_length_of(:attr).is_at_least(4)
-        }.to_not raise_exception
-      end
-    end
-
-    context "a wrong_length translation containing %{attribute}, %{model}" do
-      before do
-        stub_translation(
-          "activerecord.errors.messages.wrong_length",
-          "The %{attribute} of your %{model} is the wrong length (should be %{count} characters)")
-      end
-
-      it "does not raise an exception" do
-        expect {
-          expect(validating_length(is: 4)).
-            to validate_length_of(:attr).is_equal_to(4)
-        }.to_not raise_exception
-      end
-    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 }
-
-    define_model(:example, attribute_name => :string) do |model|
-      model.validates_length_of(attribute_name, options)
-    end
-  end
-
-  def validating_length(options = {})
-    define_model_validating_length(options).new
-  end
-
-  alias_method :build_record_validating_length, :validating_length
-
-  def validation_matcher_scenario_args
-    super.deep_merge(
-      matcher_name: :validate_length_of,
-      model_creator: :active_model
-    )
-  end
-end

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

@@ -1,1865 +0,0 @@
-require 'unit_spec_helper'
-
-describe Shoulda::Matchers::ActiveModel::ValidateNumericalityOfMatcher, type: :model do
-  class << self
-    def all_qualifiers
-      [
-        {
-          category: :comparison,
-          name: :is_greater_than,
-          argument: 1,
-          validation_name: :greater_than,
-          validation_value: 1,
-        },
-        {
-          category: :comparison,
-          name: :is_greater_than_or_equal_to,
-          argument: 1,
-          validation_name: :greater_than_or_equal_to,
-          validation_value: 1,
-        },
-        {
-          category: :comparison,
-          name: :is_less_than,
-          argument: 1,
-          validation_name: :less_than,
-          validation_value: 1,
-        },
-        {
-          category: :comparison,
-          name: :is_less_than_or_equal_to,
-          argument: 1,
-          validation_name: :less_than_or_equal_to,
-          validation_value: 1,
-        },
-        {
-          category: :comparison,
-          name: :is_equal_to,
-          argument: 1,
-          validation_name: :equal_to,
-          validation_value: 1,
-        },
-        {
-          category: :cardinality,
-          name: :odd,
-          validation_name: :odd,
-          validation_value: true,
-        },
-        {
-          category: :cardinality,
-          name: :even,
-          validation_name: :even,
-          validation_value: true,
-        },
-        {
-          name: :only_integer,
-          validation_name: :only_integer,
-          validation_value: true,
-        },
-        {
-          name: :on,
-          argument: :customizable,
-          validation_name: :on,
-          validation_value: :customizable
-        }
-      ]
-    end
-
-    def qualifiers_under(category)
-      all_qualifiers.select do |qualifier|
-        qualifier[:category] == category
-      end
-    end
-
-    def mutually_exclusive_qualifiers
-      qualifiers_under(:cardinality) + qualifiers_under(:comparison)
-    end
-
-    def non_mutually_exclusive_qualifiers
-      all_qualifiers - mutually_exclusive_qualifiers
-    end
-
-    def validations_by_qualifier
-      all_qualifiers.each_with_object({}) do |qualifier, hash|
-        hash[qualifier[:name]] = qualifier[:validation_name]
-      end
-    end
-
-    def all_qualifier_combinations
-      combinations = []
-
-      ([nil] + mutually_exclusive_qualifiers).each do |mutually_exclusive_qualifier|
-        (0..non_mutually_exclusive_qualifiers.length).each do |n|
-          non_mutually_exclusive_qualifiers.combination(n) do |combination|
-            super_combination = (
-              [mutually_exclusive_qualifier] +
-              combination
-            )
-            super_combination.select!(&:present?)
-
-            if super_combination.any?
-              combinations << super_combination
-            end
-          end
-        end
-      end
-
-      combinations
-    end
-
-    def default_qualifier_arguments
-      all_qualifiers.each_with_object({}) do |qualifier, hash|
-        hash[qualifier[:name]] = qualifier[:argument]
-      end
-    end
-
-    def default_validation_values
-      all_qualifiers.each_with_object({}) do |qualifier, hash|
-        hash[qualifier[:validation_name]] = qualifier[:validation_value]
-      end
-    end
-  end
-
-  context 'qualified with nothing' do
-    context 'and validating numericality' do
-      it 'accepts' do
-        record = build_record_validating_numericality
-        expect(record).to validate_numericality
-      end
-
-      it_supports(
-        'ignoring_interference_by_writer',
-        tests: {
-          accept_if_qualified_but_changing_value_does_not_interfere: {
-            changing_values_with: :next_value,
-          },
-          reject_if_qualified_but_changing_value_interferes: {
-            model_name: 'Example',
-            attribute_name: :attr,
-            changing_values_with: :numeric_value,
-            expected_message: <<-MESSAGE.strip
-Expected Example to validate that :attr looks like a number, but this
-could not be proved.
-  After setting :attr to ‹"abcd"› -- which was read back as ‹"1"› -- 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
-          }
-        }
-      )
-
-      context 'when the attribute is a virtual attribute in an ActiveRecord model' do
-        it 'accepts' do
-          record = build_record_validating_numericality_of_virtual_attribute
-          expect(record).to validate_numericality
-        end
-      end
-
-      context 'when the column is an integer column' do
-        it 'accepts (and does not raise an AttributeChangedValueError)' do
-          record = build_record_validating_numericality(column_type: :integer)
-          expect(record).to validate_numericality
-        end
-      end
-
-      context 'when the column is a float column' do
-        it 'accepts (and does not raise an AttributeChangedValueError)' do
-          record = build_record_validating_numericality(column_type: :float)
-          expect(record).to validate_numericality
-        end
-      end
-
-      context 'when the column is a decimal column' do
-        it 'accepts (and does not raise an AttributeChangedValueError)' do
-          record = build_record_validating_numericality(column_type: :decimal)
-          expect(record).to validate_numericality
-        end
-      end
-
-      if database_supports_money_columns?
-        context 'when the column is a money column' do
-          it 'accepts (and does not raise an AttributeChangedValueError)' do
-            record = build_record_validating_numericality(column_type: :money)
-            expect(record).to validate_numericality
-          end
-        end
-      end
-
-      context 'when used in the negative' do
-        it 'fails' do
-          assertion = lambda do
-            record = build_record_validating_numericality
-            expect(record).not_to validate_numericality
-          end
-
-          message = <<-MESSAGE
-Expected Example not to validate that :attr looks like a number, but
-this could not be proved.
-  After setting :attr to ‹"abcd"›, the matcher expected the Example to
-  be valid, but it was invalid instead, producing these validation
-  errors:
-
-  * attr: ["is not a number"]
-          MESSAGE
-
-          expect(&assertion).to fail_with_message(message)
-        end
-      end
-    end
-
-    context 'and not validating anything' do
-      it 'rejects since it does not disallow non-numbers' do
-        record = build_record_validating_nothing
-
-        assertion = -> { expect(record).to validate_numericality }
-
-        message = <<-MESSAGE
-Expected Example to validate that :attr looks like a number, but this
-could not be proved.
-  After setting :attr to ‹"abcd"›, 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 'qualified with allow_nil' do
-    context 'and validating with allow_nil' do
-      it 'accepts' do
-        record = build_record_validating_numericality(allow_nil: true)
-        expect(record).to validate_numericality.allow_nil
-      end
-
-      it_supports(
-        'ignoring_interference_by_writer',
-        tests: {
-          accept_if_qualified_but_changing_value_does_not_interfere: {
-            changing_values_with: :next_value_or_numeric_value,
-          },
-          reject_if_qualified_but_changing_value_interferes: {
-            model_name: 'Example',
-            attribute_name: :attr,
-            changing_values_with: :next_value_or_non_numeric_value,
-            expected_message: <<-MESSAGE.strip
-Expected Example to validate that :attr looks like a number as long as
-it is not nil, but this could not be proved.
-  In checking that Example allows :attr to be ‹nil›, after setting :attr
-  to ‹nil› -- which was read back as ‹"a"› -- the matcher expected the
-  Example to be valid, but it was invalid instead, producing these
-  validation errors:
-
-  * attr: ["is not a number"]
-
-  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
-          }
-        }
-      ) do
-        def validation_matcher_scenario_args
-          super.deep_merge(validation_options: { allow_nil: true })
-        end
-
-        def configure_validation_matcher(matcher)
-          matcher.allow_nil
-        end
-      end
-    end
-
-    context 'and not validating with allow_nil' do
-      it 'rejects since it tries to treat nil as a number' do
-        record = build_record_validating_numericality
-
-        assertion = lambda do
-          expect(record).to validate_numericality.allow_nil
-        end
-
-        message = <<-MESSAGE
-Expected Example to validate that :attr looks like a number as long as
-it is not nil, but this could not be proved.
-  In checking that Example allows :attr to be ‹nil›, after setting :attr
-  to ‹nil›, the matcher expected the Example to be valid, but it was
-  invalid instead, producing these validation errors:
-
-  * attr: ["is not a number"]
-        MESSAGE
-
-        expect(&assertion).to fail_with_message(message)
-      end
-    end
-  end
-
-  context 'qualified with only_integer' do
-    context 'and validating with only_integer' do
-      it 'accepts' do
-        record = build_record_validating_numericality(only_integer: true)
-        expect(record).to validate_numericality.only_integer
-      end
-
-      it_supports(
-        'ignoring_interference_by_writer',
-        tests: {
-          accept_if_qualified_but_changing_value_does_not_interfere: {
-            changing_values_with: :next_value,
-          },
-          reject_if_qualified_but_changing_value_interferes: {
-            model_name: 'Example',
-            attribute_name: :attr,
-            changing_values_with: :numeric_value,
-            expected_message: <<-MESSAGE.strip
-Expected Example to validate that :attr looks like an integer, but this
-could not be proved.
-  After setting :attr to ‹"0.1"› -- which was read back as ‹"1"› -- 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
-          }
-        }
-      ) do
-        def validation_matcher_scenario_args
-          super.deep_merge(validation_options: { only_integer: true })
-        end
-
-        def configure_validation_matcher(matcher)
-          matcher.only_integer
-        end
-      end
-    end
-
-    context 'and not validating with only_integer' do
-      it 'rejects since it does not disallow non-integers' do
-        record = build_record_validating_numericality
-
-        assertion = lambda do
-          expect(record).to validate_numericality.only_integer
-        end
-
-        message = <<-MESSAGE
-Expected Example to validate that :attr looks like an integer, but this
-could not be proved.
-  After setting :attr to ‹"0.1"›, 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 'qualified with odd' do
-    context 'and validating with odd' do
-      it 'accepts' do
-        record = build_record_validating_numericality(odd: true)
-        expect(record).to validate_numericality.odd
-      end
-
-      it_supports(
-        'ignoring_interference_by_writer',
-        tests: {
-          accept_if_qualified_but_changing_value_does_not_interfere: {
-            changing_values_with: :next_next_value,
-          },
-          reject_if_qualified_but_changing_value_interferes: {
-            model_name: 'Example',
-            attribute_name: :attr,
-            changing_values_with: :next_value,
-            expected_message: <<-MESSAGE.strip
-Expected Example to validate that :attr looks like an odd number, but
-this could not be proved.
-  After setting :attr to ‹"2"› -- which was read back as ‹"3"› -- 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
-          }
-        }
-      ) do
-        def validation_matcher_scenario_args
-          super.deep_merge(validation_options: { odd: true })
-        end
-
-        def configure_validation_matcher(matcher)
-          matcher.odd
-        end
-      end
-
-      context 'when the attribute is a virtual attribute in ActiveRecord model' do
-        it 'accepts' do
-          record = build_record_validating_numericality_of_virtual_attribute(
-            odd: true
-          )
-          expect(record).to validate_numericality.odd
-        end
-      end
-
-      context 'when the column is an integer column' do
-        it 'accepts (and does not raise an error)' do
-          record = build_record_validating_numericality(
-            column_type: :integer,
-            odd: true
-          )
-
-          expect(record).to validate_numericality.odd
-        end
-      end
-
-      context 'when the column is a float column' do
-        it 'accepts (and does not raise an error)' do
-          record = build_record_validating_numericality(
-            column_type: :float,
-            odd: true
-          )
-
-          expect(record).to validate_numericality.odd
-        end
-      end
-
-      context 'when the column is a decimal column' do
-        it 'accepts (and does not raise an error)' do
-          record = build_record_validating_numericality(
-            column_type: :decimal,
-            odd: true,
-          )
-
-          expect(record).to validate_numericality.odd
-        end
-      end
-    end
-
-    context 'and not validating with odd' do
-      it 'rejects since it does not disallow even numbers' do
-        record = build_record_validating_numericality
-
-        assertion = lambda do
-          expect(record).to validate_numericality.odd
-        end
-
-        message = <<-MESSAGE
-Expected Example to validate that :attr looks like an odd number, but
-this could not be proved.
-  After setting :attr to ‹"2"›, 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 'qualified with even' do
-    context 'and validating with even' do
-      it 'accepts' do
-        record = build_record_validating_numericality(even: true)
-        expect(record).to validate_numericality.even
-      end
-
-      it_supports(
-        'ignoring_interference_by_writer',
-        tests: {
-          accept_if_qualified_but_changing_value_does_not_interfere: {
-            changing_values_with: :next_next_value,
-          },
-          reject_if_qualified_but_changing_value_interferes: {
-            model_name: 'Example',
-            attribute_name: :attr,
-            changing_values_with: :next_value,
-            expected_message: <<-MESSAGE.strip
-Expected Example to validate that :attr looks like an even number, but
-this could not be proved.
-  After setting :attr to ‹"1"› -- which was read back as ‹"2"› -- 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
-          }
-        }
-      ) do
-        def validation_matcher_scenario_args
-          super.deep_merge(validation_options: { even: true })
-        end
-
-        def configure_validation_matcher(matcher)
-          matcher.even
-        end
-      end
-
-      context 'when the attribute is a virtual attribute in an ActiveRecord model' do
-        it 'accepts' do
-          record = build_record_validating_numericality_of_virtual_attribute(
-            even: true,
-          )
-          expect(record).to validate_numericality.even
-        end
-      end
-
-      context 'when the column is an integer column' do
-        it 'accepts (and does not raise an error)' do
-          record = build_record_validating_numericality(
-            column_type: :integer,
-            even: true
-          )
-
-          expect(record).to validate_numericality.even
-        end
-      end
-
-      context 'when the column is a float column' do
-        it 'accepts (and does not raise an error)' do
-          record = build_record_validating_numericality(
-            column_type: :float,
-            even: true
-          )
-
-          expect(record).to validate_numericality.even
-        end
-      end
-
-      context 'when the column is a decimal column' do
-        it 'accepts (and does not raise an error)' do
-          record = build_record_validating_numericality(
-            column_type: :decimal,
-            even: true,
-          )
-
-          expect(record).to validate_numericality.even
-        end
-      end
-    end
-
-    context 'and not validating with even' do
-      it 'rejects since it does not disallow odd numbers' do
-        record = build_record_validating_numericality
-
-        assertion = lambda do
-          expect(record).to validate_numericality.even
-        end
-
-        message = <<-MESSAGE
-Expected Example to validate that :attr looks like an even number, but
-this could not be proved.
-  After setting :attr to ‹"1"›, 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 'qualified with is_less_than_or_equal_to' do
-    context 'and validating with less_than_or_equal_to' do
-      it 'accepts' do
-        record = build_record_validating_numericality(
-          less_than_or_equal_to: 18
-        )
-        expect(record).to validate_numericality.is_less_than_or_equal_to(18)
-      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
-Expected Example to validate that :attr looks like a number less than or
-equal to 18, but this could not be proved.
-  After setting :attr to ‹"18"› -- which was read back as ‹"19"› -- the
-  matcher expected the Example to be valid, but it was invalid instead,
-  producing these validation errors:
-
-  * attr: ["must be less than or equal to 18"]
-
-  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
-          }
-        }
-      ) do
-        def validation_matcher_scenario_args
-          super.deep_merge(
-            validation_options: { less_than_or_equal_to: 18 }
-          )
-        end
-
-        def configure_validation_matcher(matcher)
-          matcher.is_less_than_or_equal_to(18)
-        end
-      end
-
-      context 'when the attribute is a virtual attribute in an ActiveRecord model' do
-        it 'accepts' do
-          record = build_record_validating_numericality_of_virtual_attribute(
-            less_than_or_equal_to: 18,
-          )
-          expect(record).to validate_numericality.is_less_than_or_equal_to(18)
-        end
-      end
-
-      context 'when the column is an integer column' do
-        it 'accepts (and does not raise an error)' do
-          record = build_record_validating_numericality(
-            column_type: :integer,
-            less_than_or_equal_to: 18
-          )
-
-          expect(record).to validate_numericality.is_less_than_or_equal_to(18)
-        end
-      end
-
-      context 'when the column is a float column' do
-        it 'accepts (and does not raise an error)' do
-          record = build_record_validating_numericality(
-            column_type: :float,
-            less_than_or_equal_to: 18
-          )
-
-          expect(record).to validate_numericality.is_less_than_or_equal_to(18)
-        end
-      end
-
-      context 'when the column is a decimal column' do
-        it 'accepts (and does not raise an error)' do
-          record = build_record_validating_numericality(
-            column_type: :decimal,
-            less_than_or_equal_to: 18,
-          )
-
-          expect(record).to validate_numericality.is_less_than_or_equal_to(18)
-        end
-      end
-    end
-
-    context 'and not validating with less_than_or_equal_to' do
-      it 'rejects since it does not disallow numbers greater than the value' do
-        record = build_record_validating_numericality
-
-        assertion = lambda do
-          expect(record).to validate_numericality.is_less_than_or_equal_to(18)
-        end
-
-        message = <<-MESSAGE
-Expected Example to validate that :attr looks like a number less than or
-equal to 18, but this could not be proved.
-  After setting :attr to ‹"19"›, 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 'qualified with is_less_than' do
-    context 'and validating with less_than' do
-      it 'accepts' do
-        record = build_record_validating_numericality(less_than: 18)
-        expect(record).
-          to validate_numericality.
-          is_less_than(18)
-      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
-Expected Example to validate that :attr looks like a number less than
-18, but this could not be proved.
-  After setting :attr to ‹"17"› -- which was read back as ‹"18"› -- the
-  matcher expected the Example to be valid, but it was invalid instead,
-  producing these validation errors:
-
-  * attr: ["must be less than 18"]
-
-  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
-          }
-        }
-      ) do
-        def validation_matcher_scenario_args
-          super.deep_merge(validation_options: { less_than: 18 })
-        end
-
-        def configure_validation_matcher(matcher)
-          matcher.is_less_than(18)
-        end
-      end
-
-      context 'when the attribute is a virtual attribute in an ActiveRecord model' do
-        it 'accepts' do
-          record = build_record_validating_numericality_of_virtual_attribute(
-            less_than: 18,
-          )
-          expect(record).to validate_numericality.is_less_than(18)
-        end
-      end
-
-      context 'when the column is an integer column' do
-        it 'accepts (and does not raise an error)' do
-          record = build_record_validating_numericality(
-            column_type: :integer,
-            less_than: 18
-          )
-
-          expect(record).to validate_numericality.is_less_than(18)
-        end
-      end
-
-      context 'when the column is a float column' do
-        it 'accepts (and does not raise an error)' do
-          record = build_record_validating_numericality(
-            column_type: :float,
-            less_than: 18
-          )
-
-          expect(record).to validate_numericality.is_less_than(18)
-        end
-      end
-
-      context 'when the column is a decimal column' do
-        it 'accepts (and does not raise an error)' do
-          record = build_record_validating_numericality(
-            column_type: :decimal,
-            less_than: 18,
-          )
-
-          expect(record).to validate_numericality.is_less_than(18)
-        end
-      end
-    end
-
-    context 'and not validating with less_than' do
-      it 'rejects since it does not disallow numbers greater than or equal to the value' do
-        record = build_record_validating_numericality
-
-        assertion = lambda do
-          expect(record).to validate_numericality.is_less_than(18)
-        end
-
-        message = <<-MESSAGE
-Expected Example to validate that :attr looks like a number less than
-18, but this could not be proved.
-  After setting :attr to ‹"19"›, 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 'qualified with is_equal_to' do
-    context 'and validating with equal_to' do
-      it 'accepts' do
-        record = build_record_validating_numericality(equal_to: 18)
-        expect(record).to validate_numericality.is_equal_to(18)
-      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
-Expected Example to validate that :attr looks like a number equal to 18,
-but this could not be proved.
-  After setting :attr to ‹"18"› -- which was read back as ‹"19"› -- the
-  matcher expected the Example to be valid, but it was invalid instead,
-  producing these validation errors:
-
-  * attr: ["must be equal to 18"]
-
-  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
-          }
-        }
-      ) do
-        def validation_matcher_scenario_args
-          super.deep_merge(validation_options: { equal_to: 18 })
-        end
-
-        def configure_validation_matcher(matcher)
-          matcher.is_equal_to(18)
-        end
-      end
-
-      context 'when the attribute is a virtual attribute in an ActiveRecord model' do
-        it 'accepts' do
-          record = build_record_validating_numericality_of_virtual_attribute(
-            equal_to: 18,
-          )
-          expect(record).to validate_numericality.is_equal_to(18)
-        end
-      end
-
-      context 'when the column is an integer column' do
-        it 'accepts (and does not raise an error)' do
-          record = build_record_validating_numericality(
-            column_type: :integer,
-            equal_to: 18
-          )
-
-          expect(record).to validate_numericality.is_equal_to(18)
-        end
-      end
-
-      context 'when the column is a float column' do
-        it 'accepts (and does not raise an error)' do
-          record = build_record_validating_numericality(
-            column_type: :float,
-            equal_to: 18
-          )
-
-          expect(record).to validate_numericality.is_equal_to(18)
-        end
-      end
-
-      context 'when the column is a decimal column' do
-        it 'accepts (and does not raise an error)' do
-          record = build_record_validating_numericality(
-            column_type: :decimal,
-            equal_to: 18,
-          )
-
-          expect(record).to validate_numericality.is_equal_to(18)
-        end
-      end
-    end
-
-    context 'and not validating with equal_to' do
-      it 'rejects since it does not disallow numbers that are not the value' do
-        record = build_record_validating_numericality
-
-        assertion = lambda do
-          expect(record).to validate_numericality.is_equal_to(18)
-        end
-
-        message = <<-MESSAGE
-Expected Example to validate that :attr looks like a number equal to 18,
-but this could not be proved.
-  After setting :attr to ‹"19"›, 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 'qualified with is_greater_than_or_equal to' do
-    context 'validating with greater_than_or_equal_to' do
-      it 'accepts' do
-        record = build_record_validating_numericality(
-          greater_than_or_equal_to: 18
-        )
-        expect(record).
-          to validate_numericality.
-          is_greater_than_or_equal_to(18)
-      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
-Expected Example to validate that :attr looks like a number greater than
-or equal to 18, but this could not be proved.
-  After setting :attr to ‹"17"› -- which was read back as ‹"18"› -- 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
-          }
-        }
-      ) do
-        def validation_matcher_scenario_args
-          super.deep_merge(
-            validation_options: { greater_than_or_equal_to: 18 }
-          )
-        end
-
-        def configure_validation_matcher(matcher)
-          matcher.is_greater_than_or_equal_to(18)
-        end
-      end
-
-      context 'when the attribute is a virtual attribute in an ActiveRecord model' do
-        it 'accepts' do
-          record = build_record_validating_numericality_of_virtual_attribute(
-            greater_than_or_equal_to: 18,
-          )
-          expect(record).to validate_numericality.
-            is_greater_than_or_equal_to(18)
-        end
-      end
-
-      context 'when the column is an integer column' do
-        it 'accepts (and does not raise an error)' do
-          record = build_record_validating_numericality(
-            column_type: :integer,
-            greater_than_or_equal_to: 18
-          )
-
-          expect(record).
-            to validate_numericality.
-            is_greater_than_or_equal_to(18)
-        end
-      end
-
-      context 'when the column is a float column' do
-        it 'accepts (and does not raise an error)' do
-          record = build_record_validating_numericality(
-            column_type: :float,
-            greater_than_or_equal_to: 18
-          )
-
-          expect(record).
-            to validate_numericality.
-            is_greater_than_or_equal_to(18)
-        end
-      end
-
-      context 'when the column is a decimal column' do
-        it 'accepts (and does not raise an error)' do
-          record = build_record_validating_numericality(
-            column_type: :decimal,
-            greater_than_or_equal_to: 18,
-          )
-
-          expect(record).
-            to validate_numericality.
-            is_greater_than_or_equal_to(18)
-        end
-      end
-    end
-
-    context 'not validating with greater_than_or_equal_to' do
-      it 'rejects since it does not disallow numbers that are less than the value' do
-        record = build_record_validating_numericality
-
-        assertion = lambda do
-          expect(record).to validate_numericality.
-            is_greater_than_or_equal_to(18)
-        end
-
-        message = <<-MESSAGE
-Expected Example to validate that :attr looks like a number greater than
-or equal to 18, but this could not be proved.
-  After setting :attr to ‹"17"›, 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 'qualified with is_greater_than' do
-    context 'and validating with greater_than' do
-      it 'accepts' do
-        record = build_record_validating_numericality(greater_than: 18)
-        expect(record).
-          to validate_numericality.
-          is_greater_than(18)
-      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
-Expected Example to validate that :attr looks like a number greater than
-18, but this could not be proved.
-  After setting :attr to ‹"18"› -- which was read back as ‹"19"› -- 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
-          }
-        }
-      ) do
-        def validation_matcher_scenario_args
-          super.deep_merge(validation_options: { greater_than: 18 })
-        end
-
-        def configure_validation_matcher(matcher)
-          matcher.is_greater_than(18)
-        end
-      end
-
-      context 'when the attribute is a virtual attribute in an ActiveRecord model' do
-        it 'accepts' do
-          record = build_record_validating_numericality_of_virtual_attribute(
-            greater_than: 18,
-          )
-          expect(record).to validate_numericality.is_greater_than(18)
-        end
-      end
-
-      context 'when the column is an integer column' do
-        it 'accepts (and does not raise an error)' do
-          record = build_record_validating_numericality(
-            column_type: :integer,
-            greater_than: 18
-          )
-
-          expect(record).
-            to validate_numericality.
-            is_greater_than(18)
-        end
-      end
-
-      context 'when the column is a float column' do
-        it 'accepts (and does not raise an error)' do
-          record = build_record_validating_numericality(
-            column_type: :float,
-            greater_than: 18
-          )
-
-          expect(record).
-            to validate_numericality.
-            is_greater_than(18)
-        end
-      end
-
-      context 'when the column is a decimal column' do
-        it 'accepts (and does not raise an error)' do
-          record = build_record_validating_numericality(
-            column_type: :decimal,
-            greater_than: 18,
-          )
-
-          expect(record).
-            to validate_numericality.
-            is_greater_than(18)
-        end
-      end
-    end
-
-    context 'and not validating with greater_than' do
-      it 'rejects since it does not disallow numbers that are less than or equal to the value' do
-        record = build_record_validating_numericality
-
-        assertion = lambda do
-          expect(record).to validate_numericality.is_greater_than(18)
-        end
-
-        message = <<-MESSAGE
-Expected Example to validate that :attr looks like a number greater than
-18, but this could not be proved.
-  After setting :attr to ‹"18"›, 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 'qualified with with_message' do
-    context 'and validating with the same message' do
-      it 'accepts' do
-        record = build_record_validating_numericality(message: 'custom')
-        expect(record).to validate_numericality.with_message(/custom/)
-      end
-    end
-
-    context 'and validating with a different message' do
-      it 'rejects with the correct failure message' do
-        record = build_record_validating_numericality(message: 'custom')
-
-        assertion = lambda do
-          expect(record).to validate_numericality.with_message(/wrong/)
-        end
-
-        message = <<-MESSAGE
-Expected Example to validate that :attr looks like a number, producing a
-custom validation error on failure, but this could not be proved.
-  After setting :attr to ‹"abcd"›, the matcher expected the Example to
-  be invalid and to produce a validation error matching ‹/wrong/› on
-  :attr. The record was indeed invalid, but it produced these validation
-  errors instead:
-
-  * attr: ["custom"]
-        MESSAGE
-
-        expect(&assertion).to fail_with_message(message)
-      end
-    end
-
-    context 'and no message is provided' do
-      it 'ignores the qualifier' do
-        record = build_record_validating_numericality
-        expect(record).to validate_numericality.with_message(nil)
-      end
-    end
-
-    context 'and the validation is missing from the model' do
-      it 'rejects with the correct failure message' do
-        model = define_model_validating_nothing
-
-        assertion = lambda do
-          expect(model.new).to validate_numericality.with_message(/wrong/)
-        end
-
-        message = <<-MESSAGE
-Expected Example to validate that :attr looks like a number, producing a
-custom validation error on failure, but this could not be proved.
-  After setting :attr to ‹"abcd"›, 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 'qualified with strict' do
-    context 'and validating strictly' do
-      it 'accepts' do
-        record = build_record_validating_numericality(strict: true)
-        expect(record).to validate_numericality.strict
-      end
-    end
-
-    context 'and not validating strictly' do
-      it 'rejects since ActiveModel::StrictValidationFailed is never raised' do
-        record = build_record_validating_numericality(attribute_name: :attr)
-
-        assertion = lambda do
-          expect(record).to validate_numericality_of(:attr).strict
-        end
-
-        message = <<-MESSAGE
-Expected Example to validate that :attr looks like a number, raising a
-validation exception on failure, but this could not be proved.
-  After setting :attr to ‹"abcd"›, the matcher expected the Example to
-  be invalid and to raise a validation exception, but the record
-  produced validation errors instead.
-        MESSAGE
-
-        expect(&assertion).to fail_with_message(message)
-      end
-    end
-  end
-
-  context 'qualified with on and validating with on' do
-    it 'accepts' do
-      record = build_record_validating_numericality(on: :customizable)
-      expect(record).to validate_numericality.on(:customizable)
-    end
-  end
-
-  context 'qualified with on but not validating with on' do
-    it 'accepts since the validation never considers a context' do
-      record = build_record_validating_numericality
-      expect(record).to validate_numericality.on(:customizable)
-    end
-  end
-
-  context 'not qualified with on but validating with on' do
-    it 'rejects since the validation never runs' do
-      record = build_record_validating_numericality(on: :customizable)
-
-      assertion = lambda do
-        expect(record).to validate_numericality
-      end
-
-      message = <<-MESSAGE
-Expected Example to validate that :attr looks like a number, but this
-could not be proved.
-  After setting :attr to ‹"abcd"›, the matcher expected the Example to
-  be invalid, but it was valid instead.
-      MESSAGE
-
-      expect(&assertion).to fail_with_message(message)
-    end
-  end
-
-  context 'with combinations of qualifiers together' do
-    all_qualifier_combinations.each do |combination|
-      if combination.size > 1
-        it do
-          validation_options = build_validation_options(for: combination)
-          record = build_record_validating_numericality(validation_options)
-          validate_numericality = self.validate_numericality
-          apply_qualifiers!(for: combination, to: validate_numericality)
-          expect(record).to validate_numericality
-        end
-      end
-    end
-
-    context 'when the qualifiers do not match the validation options' do
-      specify 'such as validating even but testing that only_integer is validated' do
-        record = build_record_validating_numericality(
-          even: true,
-          greater_than: 18
-        )
-
-        assertion = lambda do
-          expect(record).
-            to validate_numericality.
-            only_integer.
-            is_greater_than(18)
-        end
-
-        message = <<-MESSAGE
-Expected Example to validate that :attr looks like an integer greater
-than 18, but this could not be proved.
-  In checking that Example disallows :attr from being a decimal number,
-  after setting :attr to ‹"0.1"›, the matcher expected the Example to be
-  invalid and to produce the validation error "must be an integer" on
-  :attr. The record was indeed invalid, but it produced these validation
-  errors instead:
-
-  * attr: ["must be greater than 18"]
-        MESSAGE
-
-        expect(&assertion).to fail_with_message(message)
-      end
-
-      specify 'such as not validating only_integer but testing that only_integer is validated' do
-        record = build_record_validating_numericality(greater_than: 18)
-
-        assertion = lambda do
-          expect(record).
-            to validate_numericality.
-            only_integer.
-            is_greater_than(18)
-        end
-
-        message = <<-MESSAGE.strip_heredoc
-Expected Example to validate that :attr looks like an integer greater
-than 18, but this could not be proved.
-  In checking that Example disallows :attr from being a decimal number,
-  after setting :attr to ‹"0.1"›, the matcher expected the Example to be
-  invalid and to produce the validation error "must be an integer" on
-  :attr. The record was indeed invalid, but it produced these validation
-  errors instead:
-
-  * attr: ["must be greater than 18"]
-        MESSAGE
-
-        expect(&assertion).to fail_with_message(message)
-      end
-
-      specify 'such as validating greater_than_or_equal_to (+ even) but testing that greater_than is validated' do
-        record = build_record_validating_numericality(
-          even: true,
-          greater_than_or_equal_to: 18
-        )
-
-        assertion = lambda do
-          expect(record).
-            to validate_numericality.
-            even.
-            is_greater_than(18)
-        end
-
-        message = <<-MESSAGE
-Expected Example to validate that :attr looks like an even number
-greater than 18, but this could not be proved.
-  In checking that Example disallows :attr from being a number that is
-  not greater than 18, after setting :attr to ‹"18"›, the matcher
-  expected the Example to be invalid, but it was valid instead.
-        MESSAGE
-
-        expect(&assertion).to fail_with_message(message)
-      end
-
-      specify 'such as validating odd (+ greater_than) but testing that even is validated' do
-        record = build_record_validating_numericality(
-          odd: true,
-          greater_than: 18
-        )
-
-        assertion = lambda do
-          expect(record).
-            to validate_numericality.
-            even.
-            is_greater_than(18)
-        end
-
-        message = <<-MESSAGE
-Expected Example to validate that :attr looks like an even number
-greater than 18, but this could not be proved.
-  In checking that Example disallows :attr from being an odd number,
-  after setting :attr to ‹"1"›, the matcher expected the Example to be
-  invalid and to produce the validation error "must be even" on :attr.
-  The record was indeed invalid, but it produced these validation errors
-  instead:
-
-  * attr: ["must be greater than 18"]
-        MESSAGE
-
-        expect(&assertion).to fail_with_message(message)
-      end
-
-      specify 'such as validating greater_than_or_equal_to (+ odd) but testing that is_less_than_or_equal_to is validated' do
-        record = build_record_validating_numericality(
-          odd: true,
-          greater_than_or_equal_to: 99
-        )
-
-        assertion = lambda do
-          expect(record).
-            to validate_numericality.
-            odd.
-            is_less_than_or_equal_to(99)
-        end
-
-        message = <<-MESSAGE
-Expected Example to validate that :attr looks like an odd number less
-than or equal to 99, but this could not be proved.
-  In checking that Example disallows :attr from being a number that is
-  not less than or equal to 99, after setting :attr to ‹"101"›, the
-  matcher expected the Example to be invalid, but it was valid instead.
-        MESSAGE
-
-        expect(&assertion).to fail_with_message(message)
-      end
-
-      specify 'such as validating greater_than_or_equal_to (+ only_integer + less_than) but testing that greater_than is validated' do
-        record = build_record_validating_numericality(
-          only_integer: true,
-          greater_than_or_equal_to: 18,
-          less_than: 99
-        )
-
-        assertion = lambda do
-          expect(record).
-            to validate_numericality.
-            only_integer.
-            is_greater_than(18).
-            is_less_than(99)
-        end
-
-        message = <<-MESSAGE
-Expected Example to validate that :attr looks like an integer greater
-than 18 and less than 99, but this could not be proved.
-  In checking that Example disallows :attr from being a number that is
-  not greater than 18, after setting :attr to ‹"18"›, 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 qualifiers match the validation options but the values are different' do
-      specify 'such as testing greater_than (+ only_integer) with lower value' do
-        record = build_record_validating_numericality(
-          only_integer: true,
-          greater_than: 19
-        )
-
-        assertion = lambda do
-          expect(record).
-            to validate_numericality.
-            only_integer.
-            is_greater_than(18)
-        end
-
-        message = <<-MESSAGE
-Expected Example to validate that :attr looks like an integer greater
-than 18, but this could not be proved.
-  In checking that Example disallows :attr from being a number that is
-  not greater than 18, after setting :attr to ‹"18"›, the matcher
-  expected the Example to be invalid and to produce the validation error
-  "must be greater than 18" on :attr. The record was indeed invalid, but
-  it produced these validation errors instead:
-
-  * attr: ["must be greater than 19"]
-        MESSAGE
-
-        expect(&assertion).to fail_with_message(message)
-      end
-
-      specify 'such as testing greater_than (+ only_integer) with higher value' do
-        record = build_record_validating_numericality(
-          only_integer: true,
-          greater_than: 17
-        )
-
-        assertion = lambda do
-          expect(record).
-            to validate_numericality.
-            only_integer.
-            is_greater_than(18)
-        end
-
-        message = <<-MESSAGE
-Expected Example to validate that :attr looks like an integer greater
-than 18, but this could not be proved.
-  In checking that Example disallows :attr from being a number that is
-  not greater than 18, after setting :attr to ‹"18"›, the matcher
-  expected the Example to be invalid, but it was valid instead.
-        MESSAGE
-
-        expect(&assertion).to fail_with_message(message)
-      end
-
-      specify 'such as testing greater_than (+ even) with lower value' do
-        record = build_record_validating_numericality(
-          even: true,
-          greater_than: 20
-        )
-
-        assertion = lambda do
-          expect(record).
-            to validate_numericality.
-            even.
-            is_greater_than(18)
-        end
-
-        message = <<-MESSAGE
-Expected Example to validate that :attr looks like an even number
-greater than 18, but this could not be proved.
-  In checking that Example disallows :attr from being a number that is
-  not greater than 18, after setting :attr to ‹"18"›, the matcher
-  expected the Example to be invalid and to produce the validation error
-  "must be greater than 18" on :attr. The record was indeed invalid, but
-  it produced these validation errors instead:
-
-  * attr: ["must be greater than 20"]
-        MESSAGE
-
-        expect(&assertion).to fail_with_message(message)
-      end
-
-      specify 'such as testing greater than (+ even) with higher value' do
-        record = build_record_validating_numericality(
-          even: true,
-          greater_than: 16
-        )
-
-        assertion = lambda do
-          expect(record).
-            to validate_numericality.
-            even.
-            is_greater_than(18)
-        end
-
-        message = <<-MESSAGE
-Expected Example to validate that :attr looks like an even number
-greater than 18, but this could not be proved.
-  In checking that Example disallows :attr from being a number that is
-  not greater than 18, after setting :attr to ‹"18"›, the matcher
-  expected the Example to be invalid, but it was valid instead.
-        MESSAGE
-
-        expect(&assertion).to fail_with_message(message)
-      end
-
-      specify 'such as testing less_than_or_equal_to (+ odd) with lower value' do
-        record = build_record_validating_numericality(
-          odd: true,
-          less_than_or_equal_to: 101
-        )
-
-        assertion = lambda do
-          expect(record).
-            to validate_numericality.
-            odd.
-            is_less_than_or_equal_to(99)
-        end
-
-        message = <<-MESSAGE
-Expected Example to validate that :attr looks like an odd number less
-than or equal to 99, but this could not be proved.
-  In checking that Example disallows :attr from being a number that is
-  not less than or equal to 99, after setting :attr to ‹"101"›, the
-  matcher expected the Example to be invalid, but it was valid instead.
-        MESSAGE
-
-        expect(&assertion).to fail_with_message(message)
-      end
-
-      specify 'such as testing less_than_or_equal_to (+ odd) with higher value' do
-        record = build_record_validating_numericality(
-          odd: true,
-          less_than_or_equal_to: 97
-        )
-
-        assertion = lambda do
-          expect(record).
-            to validate_numericality.
-            odd.
-            is_less_than_or_equal_to(99)
-        end
-
-        message = <<-MESSAGE
-Expected Example to validate that :attr looks like an odd number less
-than or equal to 99, but this could not be proved.
-  In checking that Example disallows :attr from being a number that is
-  not less than or equal to 99, after setting :attr to ‹"101"›, the
-  matcher expected the Example to be invalid and to produce the
-  validation error "must be less than or equal to 99" on :attr. The
-  record was indeed invalid, but it produced these validation errors
-  instead:
-
-  * attr: ["must be less than or equal to 97"]
-        MESSAGE
-
-        expect(&assertion).to fail_with_message(message)
-      end
-
-      specify 'such as testing greater_than (+ only_integer + less_than) with lower value' do
-        record = build_record_validating_numericality(
-          only_integer: true,
-          greater_than: 19,
-          less_than: 99
-        )
-
-        assertion = lambda do
-          expect(record).
-            to validate_numericality.
-            only_integer.
-            is_greater_than(18).
-            is_less_than(99)
-        end
-
-        message = <<-MESSAGE
-Expected Example to validate that :attr looks like an integer greater
-than 18 and less than 99, but this could not be proved.
-  In checking that Example disallows :attr from being a number that is
-  not greater than 18, after setting :attr to ‹"18"›, the matcher
-  expected the Example to be invalid and to produce the validation error
-  "must be greater than 18" on :attr. The record was indeed invalid, but
-  it produced these validation errors instead:
-
-  * attr: ["must be greater than 19"]
-        MESSAGE
-
-        expect(&assertion).to fail_with_message(message)
-      end
-
-      specify 'such as testing less_than (+ only_integer + greater_than) with higher value' do
-        record = build_record_validating_numericality(
-          only_integer: true,
-          greater_than: 18,
-          less_than: 100
-        )
-
-        assertion = lambda do
-          expect(record).
-            to validate_numericality.
-            only_integer.
-            is_greater_than(18).
-            is_less_than(99)
-        end
-
-        message = <<-MESSAGE
-Expected Example to validate that :attr looks like an integer greater
-than 18 and less than 99, but this could not be proved.
-  In checking that Example disallows :attr from being a number that is
-  not less than 99, after setting :attr to ‹"100"›, the matcher expected
-  the Example to be invalid and to produce the validation error "must be
-  less than 99" on :attr. The record was indeed invalid, but it produced
-  these validation errors instead:
-
-  * attr: ["must be less than 100"]
-        MESSAGE
-
-        expect(&assertion).to fail_with_message(message)
-      end
-    end
-  end
-
-  context 'with large numbers' do
-    it do
-      record = build_record_validating_numericality(greater_than: 100_000)
-      expect(record).to validate_numericality.is_greater_than(100_000)
-    end
-
-    it do
-      record = build_record_validating_numericality(less_than: 100_000)
-      expect(record).to validate_numericality.is_less_than(100_000)
-    end
-
-    it do
-      record = build_record_validating_numericality(
-        greater_than_or_equal_to: 100_000
-      )
-      expect(record).
-        to validate_numericality.
-        is_greater_than_or_equal_to(100_000)
-    end
-
-    it do
-      record = build_record_validating_numericality(
-        less_than_or_equal_to: 100_000
-      )
-      expect(record).
-        to validate_numericality.
-        is_less_than_or_equal_to(100_000)
-    end
-  end
-
-  context 'when the subject is stubbed' do
-    it 'retains that stub while the validate_numericality is matching' do
-      model = define_model :example, attr: :string do
-        validates_numericality_of :attr, odd: true
-        before_validation :set_attr!
-        def set_attr!; self.attr = 5 end
-      end
-
-      record = model.new
-      allow(record).to receive(:set_attr!)
-
-      expect(record).to validate_numericality_of(:attr).odd
-    end
-  end
-
-  context 'against an ActiveModel model' do
-    it 'accepts' do
-      model = define_active_model_class :example, accessors: [:attr] do
-        validates_numericality_of :attr
-      end
-
-      expect(model.new).to validate_numericality_of(:attr)
-    end
-
-    it_supports(
-      'ignoring_interference_by_writer',
-      tests: {
-        accept_if_qualified_but_changing_value_does_not_interfere: {
-          changing_values_with: :next_value,
-        },
-        reject_if_qualified_but_changing_value_interferes: {
-          model_name: 'Example',
-          attribute_name: :attr,
-          changing_values_with: :numeric_value,
-          expected_message: <<-MESSAGE.strip
-Expected Example to validate that :attr looks like a number, but this
-could not be proved.
-  After setting :attr to ‹"abcd"› -- which was read back as ‹"1"› -- 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
-        }
-      }
-    )
-
-    def validation_matcher_scenario_args
-      super.deep_merge(model_creator: :active_model)
-    end
-  end
-
-  describe '#description' do
-    context 'qualified with nothing' do
-      it 'describes that it allows numbers' do
-        matcher = validate_numericality_of(:attr)
-        expect(matcher.description).to eq(
-          'validate that :attr looks like a number'
-        )
-      end
-    end
-
-    context 'qualified with only_integer' do
-      it 'describes that it allows integers' do
-        matcher = validate_numericality_of(:attr).only_integer
-        expect(matcher.description).to eq(
-          'validate that :attr looks like an integer'
-        )
-      end
-    end
-
-    qualifiers_under(:cardinality).each do |qualifier|
-      context "qualified with #{qualifier[:name]}" do
-        it "describes that it allows #{qualifier[:name]} numbers" do
-          matcher = validate_numericality_of(:attr).__send__(qualifier[:name])
-          expect(matcher.description).to eq(
-            "validate that :attr looks like an #{qualifier[:name]} number"
-          )
-        end
-      end
-    end
-
-    qualifiers_under(:comparison).each do |qualifier|
-      comparison_phrase = qualifier[:validation_name].to_s.gsub('_', ' ')
-
-      context "qualified with #{qualifier[:name]}" do
-        it "describes that it allows numbers #{comparison_phrase} a certain value" do
-          matcher = validate_numericality_of(:attr).
-            __send__(qualifier[:name], 18)
-
-          expect(matcher.description).to eq(
-            "validate that :attr looks like a number #{comparison_phrase} 18"
-          )
-        end
-      end
-    end
-
-    context 'qualified with odd + is_greater_than_or_equal_to' do
-      it "describes that it allows odd numbers greater than or equal to a certain value" do
-        matcher = validate_numericality_of(:attr).
-          odd.
-          is_greater_than_or_equal_to(18)
-
-        expect(matcher.description).to eq(
-          'validate that :attr looks like an odd number greater than or equal to 18'
-        )
-      end
-    end
-
-    context 'qualified with only integer + is_greater_than + less_than_or_equal_to' do
-      it 'describes that it allows integer greater than one value and less than or equal to another' do
-        matcher = validate_numericality_of(:attr).
-          only_integer.
-          is_greater_than(18).
-          is_less_than_or_equal_to(100)
-
-        expect(matcher.description).to eq(
-          'validate that :attr looks like an integer greater than 18 and less than or equal to 100'
-        )
-      end
-    end
-
-    context 'qualified with strict' do
-      it 'describes that it relies upon a strict validation' do
-        matcher = validate_numericality_of(:attr).strict
-        expect(matcher.description).to eq(
-          'validate that :attr looks like a number, raising a validation exception on failure'
-        )
-      end
-
-      context 'and qualified with a comparison qualifier' do
-        it 'places the comparison description after "strictly"' do
-          matcher = validate_numericality_of(:attr).is_less_than(18).strict
-          expect(matcher.description).to eq(
-            'validate that :attr looks like a number less than 18, raising a validation exception on failure'
-          )
-        end
-      end
-    end
-  end
-
-  def build_validation_options(args)
-    combination = args.fetch(:for)
-
-    combination.each_with_object({}) do |qualifier, hash|
-      value = self.class.default_validation_values.fetch(qualifier[:validation_name])
-      hash[qualifier[:validation_name]] = value
-    end
-  end
-
-  def apply_qualifiers!(args)
-    combination = args.fetch(:for)
-    matcher = args.fetch(:to)
-
-    combination.each do |qualifier|
-      args = self.class.default_qualifier_arguments.fetch(qualifier[:name])
-      matcher.__send__(qualifier[:name], *args)
-    end
-  end
-
-  def define_model_validating_numericality(options = {})
-    attribute_name = options.delete(:attribute_name) { self.attribute_name }
-    column_type = options.delete(:column_type) { :string }
-
-    define_model 'Example', attribute_name => { type: column_type } do |model|
-      model.validates_numericality_of(attribute_name, options)
-    end
-  end
-
-  def define_model_validating_numericality_of_virtual_attribute(options = {})
-    attribute_name = options.delete(:attribute_name) { self.attribute_name }
-
-    define_model 'Example' do |model|
-      model.send(:attr_accessor, attribute_name)
-      model.validates_numericality_of(attribute_name, options)
-    end
-  end
-
-  def build_record_validating_numericality_of_virtual_attribute(options = {})
-    define_model_validating_numericality_of_virtual_attribute(options).new
-  end
-
-  def build_record_validating_numericality(options = {})
-    define_model_validating_numericality(options).new
-  end
-
-  def define_model_validating_nothing
-    define_model('Example', attribute_name => :string)
-  end
-
-  def build_record_validating_nothing
-    define_model_validating_nothing.new
-  end
-
-  def validate_numericality
-    validate_numericality_of(attribute_name)
-  end
-
-  def attribute_name
-    :attr
-  end
-
-  def validation_matcher_scenario_args
-    super.deep_merge(
-      matcher_name: :validate_numericality_of,
-      model_creator: :active_record
-    )
-  end
-end