shoulda-matchers 2.8.0 → 3.0.0.rc1

data/spec/unit/shoulda/matchers/active_model/numericality_matchers/odd_number_matcher_spec.rb

@@ -45,6 +45,44 @@ describe Shoulda::Matchers::ActiveModel::NumericalityMatchers::OddNumberMatcher
     end
   end
 
+  context 'asserting strict validation when validating strictly' do
+    it 'accepts' do
+      expect(validating_odd_number(strict: true)).to subject.strict
+    end
+  end
+
+  context 'asserting non-strict validation when validating strictly' do
+    it 'rejects' do
+      pending 'This needs to be fixed'
+      expect(validating_odd_number(strict: true)).not_to subject
+    end
+  end
+
+  context 'asserting strict validation when not validating strictly' do
+    it 'rejects' do
+      expect(validating_odd_number).not_to subject.strict
+    end
+  end
+
+  context 'qualified with on and validating with on' do
+    it 'accepts' do
+      expect(validating_odd_number(on: :customizable)).
+        to subject.on(:customizable)
+    end
+  end
+
+  context 'qualified with on but not validating with on' do
+    it 'accepts since the validation never considers a context' do
+      expect(validating_odd_number).to subject.on(:customizable)
+    end
+  end
+
+  context 'not qualified with on but validating with on' do
+    it 'rejects since the validation never runs' do
+      expect(validating_odd_number(on: :customizable)).
+        not_to subject
+    end
+  end
 
   def validating_odd_number(options = {})
     define_model :example, attr: :string do
@@ -56,4 +94,4 @@ describe Shoulda::Matchers::ActiveModel::NumericalityMatchers::OddNumberMatcher
     define_model(:example, attr: :string).new
   end
 
-end
+end

data/spec/unit/shoulda/matchers/active_model/numericality_matchers/only_integer_matcher_spec.rb

@@ -45,6 +45,45 @@ describe Shoulda::Matchers::ActiveModel::NumericalityMatchers::OnlyIntegerMatche
     end
   end
 
+  context 'asserting strict validation when validating strictly' do
+    it 'accepts' do
+      expect(validating_only_integer(strict: true)).to subject.strict
+    end
+  end
+
+  context 'asserting non-strict validation when validating strictly' do
+    it 'rejects' do
+      pending 'This needs to be fixed'
+      expect(validating_only_integer(strict: true)).not_to subject
+    end
+  end
+
+  context 'asserting strict validation when not validating strictly' do
+    it 'rejects' do
+      expect(validating_only_integer).not_to subject.strict
+    end
+  end
+
+  context 'qualified with on and validating with on' do
+    it 'accepts' do
+      expect(validating_only_integer(on: :customizable)).
+        to subject.on(:customizable)
+    end
+  end
+
+  context 'qualified with on but not validating with on' do
+    it 'accepts since the validation never considers a context' do
+      expect(validating_only_integer).to subject.on(:customizable)
+    end
+  end
+
+  context 'not qualified with on but validating with on' do
+    it 'rejects since the validation never runs' do
+      expect(validating_only_integer(on: :customizable)).
+        not_to subject
+    end
+  end
+
   def validating_only_integer(options = {})
     define_model :example, attr: :string do
       validates_numericality_of :attr, { only_integer: true }.merge(options)

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

@@ -1,22 +1,5 @@
 require 'unit_spec_helper'
 
-describe Shoulda::Matchers::ActiveModel, type: :model do
-  describe '#ensure_exclusion_of' do
-    it 'is aliased to #validate_exclusion_of' do
-      allow(matchers).to receive(:validate_exclusion_of)
-
-      silence_warnings do
-        matchers.ensure_exclusion_of(:attr)
-        expect(matchers).to have_received(:validate_exclusion_of).with(:attr)
-      end
-    end
-  end
-
-  def matchers
-    @_matchers ||= Object.new.extend(described_class)
-  end
-end
-
 describe Shoulda::Matchers::ActiveModel::ValidateExclusionOfMatcher, type: :model do
   context 'an attribute which must be excluded from a range' do
     it 'accepts ensuring the correct range' do

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

@@ -1,22 +1,5 @@
 require 'unit_spec_helper'
 
-describe Shoulda::Matchers::ActiveModel, type: :model do
-  describe '#ensure_inclusion_of' do
-    it 'is aliased to #validate_inclusion_of' do
-      allow(matchers).to receive(:validate_inclusion_of)
-
-      silence_warnings do
-        matchers.ensure_inclusion_of(:attr)
-        expect(matchers).to have_received(:validate_inclusion_of)
-      end
-    end
-  end
-
-  def matchers
-    @_matchers ||= Object.new.extend(described_class)
-  end
-end
-
 describe Shoulda::Matchers::ActiveModel::ValidateInclusionOfMatcher, type: :model do
   shared_context 'for a generic attribute' do
     def self.testing_values_of_option(option_name, &block)

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

@@ -1,22 +1,5 @@
 require 'unit_spec_helper'
 
-describe Shoulda::Matchers::ActiveModel, type: :model do
-  describe '#ensure_length_of' do
-    it 'is aliased to #validate_length_of' do
-      allow(matchers).to receive(:validate_length_of)
-
-      silence_warnings do
-        matchers.ensure_length_of(:attr)
-        expect(matchers).to have_received(:validate_length_of).with(:attr)
-      end
-    end
-  end
-
-  def matchers
-    @_matchers ||= Object.new.extend(described_class)
-  end
-end
-
 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

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

@@ -1,425 +1,992 @@
 require 'unit_spec_helper'
 
 describe Shoulda::Matchers::ActiveModel::ValidateNumericalityOfMatcher, type: :model do
-  context 'with a model with a numericality validation' do
-    it 'accepts' do
-      expect(validating_numericality).to matcher
+  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
 
-    it 'does not override the default message with a blank' do
-      expect(validating_numericality).to matcher.with_message(nil)
+    def mutually_exclusive_qualifiers
+      qualifiers_under(:cardinality) + qualifiers_under(:comparison)
     end
-  end
 
-  context 'with a model without a numericality validation' do
-    it 'rejects' do
-      expect(not_validating_numericality).not_to matcher
+    def non_mutually_exclusive_qualifiers
+      all_qualifiers - mutually_exclusive_qualifiers
     end
 
-    it 'rejects with the ActiveRecord :not_a_number message' do
-      the_matcher = matcher
-      expect do
-        expect(not_validating_numericality).to the_matcher
-      end.to fail_with_message_including(
-        'Expected errors to include "is not a number"'
-      )
+    def validations_by_qualifier
+      all_qualifiers.each_with_object({}) do |qualifier, hash|
+        hash[qualifier[:name]] = qualifier[:validation_name]
+      end
     end
 
-    it 'rejects with the ActiveRecord :not_an_integer message' do
-      the_matcher = matcher.only_integer
-      expect do
-        expect(not_validating_numericality).to the_matcher
-      end.to fail_with_message_including(
-        'Expected errors to include "must be an integer"'
-      )
+    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
 
-    it 'rejects with the ActiveRecord :odd message' do
-      the_matcher = matcher.odd
-      expect do
-        expect(not_validating_numericality).to the_matcher
-      end.to fail_with_message_including(
-        'Expected errors to include "must be odd"'
-      )
+    def default_qualifier_arguments
+      all_qualifiers.each_with_object({}) do |qualifier, hash|
+        hash[qualifier[:name]] = qualifier[:argument]
+      end
     end
 
-    it 'rejects with the ActiveRecord :even message' do
-      the_matcher = matcher.even
-      expect do
-        expect(not_validating_numericality).to the_matcher
-      end.to fail_with_message_including(
-        'Expected errors to include "must be even"'
-      )
+    def default_validation_values
+      all_qualifiers.each_with_object({}) do |qualifier, hash|
+        hash[qualifier[:validation_name]] = qualifier[:validation_value]
+      end
     end
   end
 
-  context 'with the allow_nil option' do
-    it 'allows nil values for that attribute' do
-      expect(validating_numericality(allow_nil: true)).to matcher.allow_nil
+  context 'qualified with nothing' do
+    context 'and validating numericality' do
+      it 'accepts' do
+        record = build_record_validating_numericality
+        expect(record).to validate_numericality
+      end
     end
 
-    it 'rejects when the model does not allow nil' do
-      the_matcher = matcher.allow_nil
-      expect {
-        expect(validating_numericality).to the_matcher
-      }.to fail_with_message_including('Did not expect errors to include "is not a number"')
+    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 }
+        expect(&assertion).to fail_with_message_including(
+          'Expected errors to include "is not a number"'
+        )
+      end
     end
   end
 
-  context 'with the only_integer option' do
-    it 'allows integer values for that attribute' do
-      expect(validating_numericality(only_integer: true)).to matcher.only_integer
+  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
     end
 
-    it 'rejects when the model does not enforce integer values' do
-      expect(validating_numericality).not_to matcher.only_integer
+    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
+        expect(&assertion).to fail_with_message_including(
+          %[Did not expect errors to include "is not a number" when #{attribute_name} is set to nil]
+        )
+      end
     end
+  end
 
-    it 'rejects with the ActiveRecord :not_an_integer message' do
-      the_matcher = matcher.only_integer
-      expect do
-        expect(validating_numericality).to the_matcher
-      end.to fail_with_message_including(
-        'Expected errors to include "must be an integer"'
-      )
+  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
     end
-  end
 
-  context 'with the odd option' do
-    it 'allows odd number values for that attribute' do
-      expect(validating_numericality(odd: true)).to matcher.odd
+    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
+        expect(&assertion).to fail_with_message_including(
+          'Expected errors to include "must be an integer"'
+        )
+      end
     end
+  end
 
-    it 'rejects when the model does not enforce odd number values' do
-      expect(validating_numericality).not_to matcher.odd
+  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
     end
 
-    it 'rejects with the ActiveRecord :odd message' do
-      the_matcher = matcher.odd
-      expect do
-        expect(validating_numericality).to the_matcher
-      end.to fail_with_message_including(
-        'Expected errors to include "must be odd"'
-      )
+    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
+        expect(&assertion).to fail_with_message_including(
+          'Expected errors to include "must be odd"'
+        )
+      end
     end
   end
 
-  context 'with the even option' do
-    it 'allows even number values for that attribute' do
-      expect(validating_numericality(even: true)).to matcher.even
+  context 'qualified with even' do
+    context 'and validating with even' do
+      it 'allows even number values for that attribute' do
+        record = build_record_validating_numericality(even: true)
+        expect(record).to validate_numericality.even
+      end
     end
 
-    it 'rejects when the model does not enforce even number values' do
-      expect(validating_numericality).not_to matcher.even
+    context 'and not validating with even' do
+      it 'rejects since it does not disallow odd numbers' do
+        record = build_record_validating_numericality
+        assertion = -> { expect(record).to validate_numericality.even }
+        expect(&assertion).to fail_with_message_including(
+          'Expected errors to include "must be even"'
+        )
+      end
     end
+  end
 
-    it 'rejects with the ActiveRecord :even message' do
-      the_matcher = matcher.even
-      expect do
-        expect(validating_numericality).to the_matcher
-      end.to fail_with_message_including(
-        'Expected errors to include "must be even"'
-      )
+  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
+
+      context 'if the given value is right at the allowed max value for the column' do
+        it 'does not raise an error' do
+          record = build_record_with_integer_column_of_limit(2,
+            less_than_or_equal_to: 32767
+          )
+          assertion = lambda do
+            expect(record).
+              to validate_numericality.
+              is_less_than_or_equal_to(32767)
+          end
+          expect(&assertion).not_to raise_error
+        end
+      end
     end
-  end
 
-  context 'qualified with less_than_or_equal_to' do
-    it 'does not raise an error if the given value is right at the allowed max value for the column' do
-      record = record_with_integer_column_of_limit(:attr, 2, less_than_or_equal_to: 32767)
-      assertion = -> {
-        expect(record).to validate_numericality_of(:attr).is_less_than_or_equal_to(32767)
-      }
-      expect(&assertion).not_to raise_error
+    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
+        expect(&assertion).to fail_with_message_including(
+          'Expected errors to include "must be less than or equal to 18"'
+        )
+      end
     end
   end
 
-  context 'qualified with less_than' do
-    it 'does not raise an error if the given value is right at the allowed max value for the column' do
-      record = record_with_integer_column_of_limit(:attr, 2, less_than: 32767)
-      assertion = -> {
-        expect(record).to validate_numericality_of(:attr).is_less_than(32767)
-      }
-      expect(&assertion).not_to raise_error
+  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
+
+      context 'if the given value is right at the allowed max value for the column' do
+        it 'does not raise an error' do
+          record = build_record_with_integer_column_of_limit(2, less_than: 32767)
+          assertion = lambda do
+            expect(record).to validate_numericality.is_less_than(32767)
+          end
+          expect(&assertion).not_to raise_error
+        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
+        expect(&assertion).to fail_with_message_including(
+          'Expected errors to include "must be less than 18"'
+        )
+      end
     end
   end
 
-  context 'qualified with equal_to' do
-    it 'does not raise an error if the given value is right at the allowed min value for the column' do
-      record = record_with_integer_column_of_limit(:attr, 2, equal_to: -32768)
-      assertion = -> {
-        expect(record).to validate_numericality_of(:attr).is_equal_to(-32768)
-      }
-      expect(&assertion).not_to raise_error
+  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
+
+      context 'if the given value is right at the allowed min value for the column' do
+        it 'does not raise an error' do
+          record = build_record_with_integer_column_of_limit(2, equal_to: -32768)
+          assertion = lambda do
+            expect(record).to validate_numericality.is_equal_to(-32768)
+          end
+          expect(&assertion).not_to raise_error
+        end
+      end
+
+      context 'if the given value is right at the allowed max value for the column' do
+        it 'does not raise an error' do
+          record = build_record_with_integer_column_of_limit(2, equal_to: 32767)
+          assertion = lambda do
+            expect(record).to validate_numericality.is_equal_to(32767)
+          end
+          expect(&assertion).not_to raise_error
+        end
+      end
     end
 
-    it 'does not raise an error if the given value is right at the allowed max value for the column' do
-      record = record_with_integer_column_of_limit(:attr, 2, equal_to: 32767)
-      assertion = -> {
-        expect(record).to validate_numericality_of(:attr).is_equal_to(32767)
-      }
-      expect(&assertion).not_to raise_error
+    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
+        expect(&assertion).to fail_with_message_including(
+          'Expected errors to include "must be equal to 18"'
+        )
+      end
     end
   end
 
-  context 'qualified with greater_than_or_equal to' do
-    it 'does not raise an error if the given value is right at the allowed min value for the column' do
-      record = record_with_integer_column_of_limit(:attr, 2,
-        greater_than_or_equal_to: -32768
-      )
-      assertion = -> {
+  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_of(:attr).
-          is_greater_than_or_equal_to(-32768)
-      }
-      expect(&assertion).not_to raise_error
+          to validate_numericality.
+          is_greater_than_or_equal_to(18)
+      end
+
+      context 'if the given value is right at the allowed min value for the column' do
+        it 'does not raise an error' do
+          record = build_record_with_integer_column_of_limit(2,
+            greater_than_or_equal_to: -32768
+          )
+          assertion = lambda do
+            expect(record).
+              to validate_numericality_of(:attr).
+              is_greater_than_or_equal_to(-32768)
+          end
+          expect(&assertion).not_to raise_error
+        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
+        expect(&assertion).to fail_with_message_including(
+          'Expected errors to include "must be greater than or equal to 18"'
+        )
+      end
     end
   end
 
-  context 'qualified with greater_than' do
-    it 'does not raise an error if the given value is right at the allowed min value for the column' do
-      record = record_with_integer_column_of_limit(:attr, 2,
-        greater_than: -32768
-      )
-      assertion = -> {
+  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_of(:attr).
-          is_greater_than(-32768)
-      }
-      expect(&assertion).not_to raise_error
+          to validate_numericality.
+          is_greater_than(18)
+      end
+
+      context 'if the given value is right at the allowed min value for the column' do
+        it 'does not raise an error' do
+          record = build_record_with_integer_column_of_limit(2,
+            greater_than: -32768
+          )
+          assertion = lambda do
+            expect(record).
+              to validate_numericality_of(:attr).
+              is_greater_than(-32768)
+          end
+          expect(&assertion).not_to raise_error
+        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
+        expect(&assertion).to fail_with_message_including(
+          'Expected errors to include "must be greater than 18"'
+        )
+      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' do
+        record = build_record_validating_numericality(message: 'custom')
+        expect(record).not_to validate_numericality.with_message(/wrong/)
+      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
   end
 
-  context 'with multiple options together' do
-    context 'the success cases' do
-      it do
-        expect(validating_numericality(only_integer: true, greater_than: 18))
-          .to matcher.only_integer.is_greater_than(18)
+  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
 
-      it do
-        expect(validating_numericality(even: true, greater_than: 18))
-          .to matcher.even.is_greater_than(18)
+    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
+        expect(&assertion).to fail_with_message_including(
+          'Expected exception to include "Attr is not a number"'
+        )
       end
-      it do
-        expect(validating_numericality(odd: true, less_than_or_equal_to: 99))
-          .to matcher.odd.is_less_than_or_equal_to(99)
+    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
+      expect(&assertion).to fail_with_message_including(
+        'Expected errors to include "is not a number"'
+      )
+    end
+  end
 
-      it do
-        expect(validating_numericality(
-                 only_integer: true,
-                 greater_than: 18,
-                 less_than: 99)
-        ).to matcher.only_integer.is_greater_than(18).is_less_than(99)
+  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 'the failure cases with different validators' do
-      it do
-        expect(validating_numericality(even: true, greater_than: 18))
-          .not_to matcher.only_integer.is_greater_than(18)
+    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 = format_message_according_to_rails_version(
+          <<-MESSAGE.strip_heredoc
+            Expected errors to include "must be an integer" when attr is set to 0.1,
+            got errors:
+            * "must be greater than 18" (attribute: attr, value: "0.1")
+          MESSAGE
+        )
+        expect(&assertion).to fail_with_message(message)
       end
 
-      it do
-        expect(validating_numericality(greater_than: 18))
-          .not_to matcher.only_integer.is_greater_than(18)
+      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 = format_message_according_to_rails_version(
+          <<-MESSAGE.strip_heredoc
+            Expected errors to include "must be an integer" when attr is set to 0.1,
+            got errors:
+            * "must be greater than 18" (attribute: attr, value: "0.1")
+          MESSAGE
+        )
+        expect(&assertion).to fail_with_message(message)
       end
 
-      it do
-        expect(
-          validating_numericality(even: true, greater_than_or_equal_to: 18)
-        ).not_to matcher.even.is_greater_than(18)
+      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 = format_message_according_to_rails_version(
+          <<-MESSAGE.strip_heredoc
+            Expected errors to include "must be greater than 18" when attr is set to 18,
+            got no errors
+          MESSAGE
+        )
+        expect(&assertion).to fail_with_message(message)
       end
 
-      it do
-        expect(validating_numericality(odd: true, greater_than: 18))
-          .not_to matcher.even.is_greater_than(18)
+      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 = format_message_according_to_rails_version(
+          <<-MESSAGE.strip_heredoc
+            Expected errors to include "must be even" when attr is set to 1,
+            got errors:
+            * "must be greater than 18" (attribute: attr, value: "1")
+          MESSAGE
+        )
+        expect(&assertion).to fail_with_message(message)
       end
 
-      it do
-        expect(validating_numericality(
-                 odd: true,
-                 greater_than_or_equal_to: 99
-               )
-        ).not_to matcher.odd.is_less_than_or_equal_to(99)
+      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 = format_message_according_to_rails_version(
+          <<-MESSAGE.strip_heredoc
+            Expected errors to include "must be less than or equal to 99" when attr is set to 101,
+            got no errors
+          MESSAGE
+        )
+        expect(&assertion).to fail_with_message(message)
       end
 
-      it do
-        expect(validating_numericality(
-                 only_integer: true,
-                 greater_than_or_equal_to: 18,
-                 less_than: 99
-               )
-        ).not_to matcher.only_integer.is_greater_than(18).is_less_than(99)
+      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 = format_message_according_to_rails_version(
+          <<-MESSAGE.strip_heredoc
+            Expected errors to include "must be greater than 18" when attr is set to 18,
+            got no errors
+          MESSAGE
+        )
+        expect(&assertion).to fail_with_message(message)
       end
     end
 
-    context 'the failure cases with wrong values' do
-      it do
-        expect(validating_numericality(only_integer: true, greater_than: 19))
-          .not_to matcher.only_integer.is_greater_than(18)
+    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 = format_message_according_to_rails_version(
+          <<-MESSAGE.strip_heredoc
+            Expected errors to include "must be greater than 18" when attr is set to 18,
+            got errors:
+            * "must be greater than 19" (attribute: attr, value: "19")
+          MESSAGE
+        )
+        expect(&assertion).to fail_with_message(message)
       end
 
-      it do
-        expect(validating_numericality(only_integer: true, greater_than: 17))
-          .not_to matcher.only_integer.is_greater_than(18)
+      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 = format_message_according_to_rails_version(
+          <<-MESSAGE.strip_heredoc
+            Expected errors to include "must be greater than 18" when attr is set to 18,
+            got no errors
+          MESSAGE
+        )
+        expect(&assertion).to fail_with_message(message)
       end
 
-      it do
-        expect(validating_numericality(even: true, greater_than: 20))
-          .not_to matcher.even.is_greater_than(18)
+      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 = format_message_according_to_rails_version(
+          <<-MESSAGE.strip_heredoc
+            Expected errors to include "must be greater than 18" when attr is set to 18,
+            got errors:
+            * "must be greater than 20" (attribute: attr, value: "20")
+          MESSAGE
+        )
+        expect(&assertion).to fail_with_message(message)
       end
 
-      it do
-        expect(validating_numericality(even: true, greater_than: 16))
-          .not_to matcher.even.is_greater_than(18)
+      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 = format_message_according_to_rails_version(
+          <<-MESSAGE.strip_heredoc
+            Expected errors to include "must be greater than 18" when attr is set to 18,
+            got no errors
+          MESSAGE
+        )
+        expect(&assertion).to fail_with_message(message)
       end
 
-      it do
-        expect(validating_numericality(odd: true, less_than_or_equal_to: 101))
-         .not_to matcher.odd.is_less_than_or_equal_to(99)
+      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 = format_message_according_to_rails_version(
+          <<-MESSAGE.strip_heredoc
+            Expected errors to include "must be less than or equal to 99" when attr is set to 101,
+            got no errors
+          MESSAGE
+        )
+        expect(&assertion).to fail_with_message(message)
       end
 
-      it do
-        expect(validating_numericality(odd: true, less_than_or_equal_to: 97))
-          .not_to matcher.odd.is_less_than_or_equal_to(99)
+      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 = format_message_according_to_rails_version(
+          <<-MESSAGE.strip_heredoc
+            Expected errors to include "must be less than or equal to 99" when attr is set to 101,
+            got errors:
+            * "must be less than or equal to 97" (attribute: attr, value: "101")
+          MESSAGE
+        )
+        expect(&assertion).to fail_with_message(message)
       end
 
-      it do
-        expect(validating_numericality(only_integer: true,
-                                          greater_than: 19,
-                                          less_than: 99))
-          .not_to matcher.only_integer.is_greater_than(18).is_less_than(99)
+      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 = format_message_according_to_rails_version(
+          <<-MESSAGE.strip_heredoc
+            Expected errors to include "must be greater than 18" when attr is set to 18,
+            got errors:
+            * "must be greater than 19" (attribute: attr, value: "19")
+          MESSAGE
+        )
+        expect(&assertion).to fail_with_message(message)
       end
 
-      it do
-        expect(validating_numericality(only_integer: true,
-                                          greater_than: 18,
-                                          less_than: 100))
-          .not_to matcher.only_integer.is_greater_than(18).is_less_than(99)
+      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 = format_message_according_to_rails_version(
+          <<-MESSAGE.strip_heredoc
+            Expected errors to include "must be less than 99" when attr is set to 100,
+            got errors:
+            * "must be less than 100" (attribute: attr, value: "100")
+          MESSAGE
+        )
+        expect(&assertion).to fail_with_message(message)
       end
     end
   end
 
   context 'with large numbers' do
     it do
-      expect(validating_numericality(greater_than: 100_000))
-        .to matcher.is_greater_than(100_000)
+      record = build_record_validating_numericality(greater_than: 100_000)
+      expect(record).to validate_numericality.is_greater_than(100_000)
     end
 
     it do
-      expect(validating_numericality(less_than: 100_000))
-        .to matcher.is_less_than(100_000)
+      record = build_record_validating_numericality(less_than: 100_000)
+      expect(record).to validate_numericality.is_less_than(100_000)
     end
 
     it do
-      expect(validating_numericality(greater_than_or_equal_to: 100_000))
-        .to matcher.is_greater_than_or_equal_to(100_000)
+      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
-      expect(validating_numericality(less_than_or_equal_to: 100_000))
-        .to matcher.is_less_than_or_equal_to(100_000)
-    end
-  end
-
-  context 'with a custom validation message' do
-    it 'accepts when the messages match' do
-      expect(validating_numericality(message: 'custom')).
-          to matcher.with_message(/custom/)
-    end
-
-    it 'rejects when the messages do not match' do
-      expect(validating_numericality(message: 'custom')).
-          not_to matcher.with_message(/wrong/)
+      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 stubs on submatchers' do
-      subject = define_model :example, attr: :string 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.new
+      end
 
-      allow(subject).to receive(:set_attr!)
-      expect(subject).to matcher.odd
+      record = model.new
+      allow(record).to receive(:set_attr!)
+
+      expect(record).to validate_numericality_of(:attr).odd
     end
   end
 
   describe '#description' do
-    context 'without submatchers' do
-      it { expect(matcher.description).to eq 'only allow numbers for attr' }
+    context 'qualified with nothing' do
+      it 'describes that it allows numbers' do
+        matcher = validate_numericality_of(:attr)
+        expect(matcher.description).to eq 'only allow numbers for attr'
+      end
     end
 
-    context 'with only integer option' do
-      it do
-        expect(matcher.only_integer.description)
-          .to eq 'only allow integers for attr'
+    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 'only allow integers for attr'
       end
     end
 
-    [:odd, :even].each do |type|
-      context "with #{type} option" do
-        it do
-          expect(matcher.__send__(type).description)
-            .to eq "only allow #{type} numbers for attr"
+    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 "only allow #{qualifier[:name]} numbers for attr"
         end
       end
     end
 
-    [:is_greater_than,
-     :is_greater_than_or_equal_to,
-     :is_less_than,
-     :is_less_than_or_equal_to,
-     :is_equal_to ].each do |comparison|
-      context "with #{comparison} option" do
-        it do
-          expect(matcher.__send__(comparison, 18).description)
-          .to eq(
-            'only allow numbers for attr which are ' +
-            "#{comparison.to_s.sub('is_', '').gsub('_', ' ')} 18"
+    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(
+            "only allow numbers for attr which are #{comparison_phrase} 18"
           )
         end
       end
     end
 
-    context 'with odd, is_greater_than_or_equal_to option' do
-      it do
-        expect(matcher.odd.is_greater_than_or_equal_to(18).description)
-          .to eq(
-            'only allow odd numbers for attr ' +
-            'which are greater than or equal to 18'
+    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(
+          'only allow odd numbers for attr which are 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(
+          'only allow integers for attr which are 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(
+          'only allow numbers for attr, strictly'
+        )
+      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(
+            'only allow numbers for attr, strictly, which are less than 18'
           )
+        end
       end
     end
+  end
 
-    context 'with only integer, is_greater_than and less_than_or_equal_to option' do
-      it { expect(matcher.only_integer.is_greater_than(18).is_less_than_or_equal_to(100).description).
-          to eq "only allow integers for attr which are greater than 18 and less than or equal to 100" }
+  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 }
+
+    define_model 'Example', attribute_name => :string do |model|
+      model.validates_numericality_of(attribute_name, options)
+    end
+  end
 
-  def validating_numericality(options = {})
-    define_model :example, attr: :string do
-      validates_numericality_of :attr, options
-    end.new
+  def build_record_validating_numericality(options = {})
+    define_model_validating_numericality(options).new
   end
 
-  def not_validating_numericality
-    define_model(:example, attr: :string).new
+  def define_model_validating_nothing
+    define_model('Example', attribute_name => :string)
   end
 
-  def matcher
-    validate_numericality_of(:attr)
+  def build_record_validating_nothing
+    define_model_validating_nothing.new
   end
 
-  def record_with_integer_column_of_limit(attribute, limit, validation_options = {})
+  def validate_numericality
+    validate_numericality_of(attribute_name)
+  end
+
+  def attribute_name
+    :attr
+  end
+
+  def define_model_with_integer_column_of_limit(limit, validation_options = {})
     column_options = { type: :integer, options: { limit: limit } }
-    define_model :example, attribute => column_options do
-      validates_numericality_of attribute, validation_options
-    end.new
+    define_model :example, attribute_name => column_options do |model|
+      model.validates_numericality_of(attribute_name, validation_options)
+    end
+  end
+
+  def build_record_with_integer_column_of_limit(limit, validation_options = {})
+    define_model_with_integer_column_of_limit(limit, validation_options).new
+  end
+
+  def format_message_according_to_rails_version(message)
+    if rails_gte_4_2?
+      message
+    else
+      message.gsub(/"((?:\d+)(?:\.\d+)?)"/, '\1')
+    end
   end
 end