shoulda-matchers 3.0.0.rc1 → 3.0.0

data/spec/unit/shoulda/matchers/action_controller/set_flash_matcher_spec.rb

@@ -40,4 +40,28 @@ describe Shoulda::Matchers::ActionController::SetFlashMatcher, type: :controller
       expect(controller).not_to set_flash.now['key for flash']
     end
   end
+
+  context 'when the now qualifier is called after the key is set' do
+    it 'raises a QualifierOrderError' do
+      controller = build_fake_response
+
+      usage = lambda do
+        expect(controller).to set_flash['any key'].now
+      end
+
+      expect(&usage).to raise_error(described_class::QualifierOrderError)
+    end
+  end
+
+  context 'when the now qualifier is called after the to qualifier' do
+    it 'raises a QualifierOrderError' do
+      controller = build_fake_response
+
+      usage = lambda do
+        expect(controller).to set_flash.to('any value').now
+      end
+
+      expect(&usage).to raise_error(described_class::QualifierOrderError)
+    end
+  end
 end

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

@@ -1,6 +1,6 @@
 require 'unit_spec_helper'
 
-describe Shoulda::Matchers::ActiveModel do
+describe Shoulda::Matchers::ActiveModel, type: :model do
   describe '#allow_values' do
     it 'is aliased to #allow_value' do
       expect(method(:allow_values)).to eq(method(:allow_value))
@@ -62,7 +62,9 @@ describe Shoulda::Matchers::ActiveModel::AllowValueMatcher, type: :model do
 
     it 'rejects several bad values' do
       expect(validating_format(with: /abc/)).
-        not_to allow_value('xyz', 'zyx', nil, []).for(:attr)
+        not_to allow_value('xyz', 'zyx', nil, []).
+        for(:attr).
+        ignoring_interference_by_writer
     end
   end
 
@@ -182,12 +184,18 @@ describe Shoulda::Matchers::ActiveModel::AllowValueMatcher, type: :model do
 
     it 'does not match given a bad value' do
       bad_values.each do |bad_value|
-        expect(model).not_to allow_value(bad_value).for(:attr)
+        expect(model).
+          not_to allow_value(bad_value).
+          for(:attr).
+          ignoring_interference_by_writer
       end
     end
 
     it 'does not match given multiple bad values' do
-      expect(model).not_to allow_value(*bad_values).for(:attr)
+      expect(model).
+        not_to allow_value(*bad_values).
+        for(:attr).
+        ignoring_interference_by_writer
     end
 
     it "does not match given good values along with bad values" do
@@ -241,130 +249,139 @@ describe Shoulda::Matchers::ActiveModel::AllowValueMatcher, type: :model do
     end
   end
 
-  if active_record_can_raise_range_error?
-    context 'when the value is outside of the range of the column' do
-      context 'not qualified with strict' do
-        it 'rejects, failing with the correct message' do
-          type = :integer
-          attribute_options = { type: type, options: { limit: 2 } }
-          record = define_model(:example, attr: attribute_options).new
-          assertion = -> { expect(record).to allow_value(100000).for(:attr) }
-          column_type_class = column_type_class_for(type)
-          message = <<-MESSAGE.strip_heredoc.strip
-            Did not expect errors when attr is set to 100000,
-            got RangeError: "100000 is out of range for #{column_type_class} with limit 2"
-          MESSAGE
-          expect(&assertion).to fail_with_message(message)
-        end
+  context 'when the attribute interferes with attempts to be set' do
+    context 'when the matcher has not been qualified with #ignoring_interference_by_writer' do
+      context 'when the attribute cannot be changed from nil to non-nil' do
+        it 'raises a CouldNotSetAttributeError' do
+          model = define_active_model_class 'Example' do
+            attr_reader :name
 
-        context 'qualified with a message' do
-          it 'ignores any specified message, failing with the correct message' do
-            type = :integer
-            attribute_options = { type: type, options: { limit: 2 } }
-            record = define_model(:example, attr: attribute_options).new
-            assertion = -> do
-              expect(record).
-                to allow_value(100000).
-                for(:attr).
-                with_message('some message')
+            def name=(_value)
+              nil
             end
-            column_type_class = column_type_class_for(type)
-            message = <<-MESSAGE.strip_heredoc.strip
-              Did not expect errors to include "some message" when attr is set to 100000,
-              got RangeError: "100000 is out of range for #{column_type_class} with limit 2"
-            MESSAGE
-            expect(&assertion).to fail_with_message(message)
           end
+
+          assertion = -> {
+            expect(model.new).to allow_value('anything').for(:name)
+          }
+
+          expect(&assertion).to raise_error(
+            described_class::CouldNotSetAttributeError
+          )
         end
       end
 
-      if active_model_supports_strict?
-        context 'qualified with strict' do
-          it 'rejects, failing with the correct message' do
-            type = :integer
-            attribute_options = { type: type, options: { limit: 2 } }
-            record = define_model(:example, attr: attribute_options).new
-            assertion = -> do
-              expect(record).
-                to allow_value(100000).
-                for(:attr).
-                strict
+      context 'when the attribute cannot be changed from non-nil to nil' do
+        it 'raises a CouldNotSetAttribute error' do
+          model = define_active_model_class 'Example' do
+            attr_reader :name
+
+            def name=(value)
+              @name = value unless value.nil?
             end
-            column_type_class = column_type_class_for(type)
-            message = <<-MESSAGE.strip_heredoc.strip
-              Did not expect an exception to have been raised when attr is set to 100000,
-              got RangeError: "100000 is out of range for #{column_type_class} with limit 2"
-            MESSAGE
-            expect(&assertion).to fail_with_message(message)
           end
 
-          context 'qualified with a message' do
-            it 'ignores any specified message' do
-              type = :integer
-              attribute_options = { type: type, options: { limit: 2 } }
-              record = define_model(:example, attr: attribute_options).new
-              assertion = -> do
-                expect(record).
-                  to allow_value(100000).
-                  for(:attr).
-                  with_message('some message').
-                  strict
-              end
-              column_type_class = column_type_class_for(type)
-              message = <<-MESSAGE.strip_heredoc.strip
-                Did not expect exception to include "some message" when attr is set to 100000,
-                got RangeError: "100000 is out of range for #{column_type_class} with limit 2"
-              MESSAGE
-              expect(&assertion).to fail_with_message(message)
+          record = model.new(name: 'some name')
+
+          assertion = -> {
+            expect(record).to allow_value(nil).for(:name)
+          }
+
+          expect(&assertion).to raise_error(
+            described_class::CouldNotSetAttributeError
+          )
+        end
+      end
+
+      context 'when the attribute cannot be changed from a non-nil value to another non-nil value' do
+        it 'raises a CouldNotSetAttribute error' do
+          model = define_active_model_class 'Example' do
+            attr_reader :name
+
+            def name=(_value)
+              @name = 'constant name'
             end
           end
+
+          record = model.new(name: 'some name')
+
+          assertion = -> {
+            expect(record).to allow_value('another name').for(:name)
+          }
+
+          expect(&assertion).to raise_error(
+            described_class::CouldNotSetAttributeError
+          )
         end
       end
     end
-  end
 
-  context 'when the attribute writer method ignores a non-nil value' do
-    context 'when the attribute has a reader method' do
-      it 'raises a CouldNotSetAttributeError' do
-        model = define_active_model_class 'Example' do
-          attr_reader :name
+    context 'when the matcher has been qualified with #ignoring_interference_by_writer' do
+      context 'when the attribute cannot be changed from nil to non-nil' do
+        it 'does not raise an error at all' do
+          model = define_active_model_class 'Example' do
+            attr_reader :name
 
-          def name=(_value)
-            nil
+            def name=(_value)
+              nil
+            end
           end
-        end
 
-        assertion = -> {
-          expect(model.new).to allow_value('anything').for(:name)
-        }
+          assertion = lambda do
+            expect(model.new).
+              to allow_value('anything').
+              for(:name).
+              ignoring_interference_by_writer
+          end
 
-        expect(&assertion).to raise_error(
-          Shoulda::Matchers::ActiveModel::AllowValueMatcher::CouldNotSetAttributeError
-        )
+          expect(&assertion).not_to raise_error
+        end
       end
-    end
-  end
 
-  context 'when the attribute writer method ignores a nil value' do
-    context 'when the attribute has a reader method' do
-      it 'raises a CouldNotSetAttribute error' do
-        model = define_active_model_class 'Example' do
-          attr_reader :name
+      context 'when the attribute cannot be changed from non-nil to nil' do
+        it 'does not raise an error at all' do
+          model = define_active_model_class 'Example' do
+            attr_reader :name
+
+            def name=(value)
+              @name = value unless value.nil?
+            end
+          end
+
+          record = model.new(name: 'some name')
 
-          def name=(value)
-            @name = value unless value.nil?
+          assertion = lambda do
+            expect(record).
+              to allow_value(nil).
+              for(:name).
+              ignoring_interference_by_writer
           end
+
+          expect(&assertion).not_to raise_error
         end
+      end
 
-        record = model.new(name: 'some name')
+      context 'when the attribute cannot be changed from a non-nil value to another non-nil value' do
+        it 'does not raise an error at all' do
+          model = define_active_model_class 'Example' do
+            attr_reader :name
 
-        assertion = -> {
-          expect(record).to allow_value(nil).for(:name)
-        }
+            def name=(_value)
+              @name = 'constant name'
+            end
+          end
 
-        expect(&assertion).to raise_error(
-          Shoulda::Matchers::ActiveModel::AllowValueMatcher::CouldNotSetAttributeError
-        )
+          record = model.new(name: 'some name')
+
+          assertion = lambda do
+            expect(record).
+              to allow_value('another name').
+              for(:name).
+              ignoring_interference_by_writer
+          end
+
+          expect(&assertion).not_to raise_error
+        end
       end
     end
   end

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

@@ -79,88 +79,6 @@ describe Shoulda::Matchers::ActiveModel::DisallowValueMatcher, type: :model do
     end
   end
 
-  if active_record_can_raise_range_error?
-    context 'when the value is outside of the range of the column' do
-      context 'not qualified with strict' do
-        it 'accepts, failing with the correct message' do
-          type = :integer
-          attribute_options = { type: type, options: { limit: 2 } }
-          record = define_model(:example, attr: attribute_options).new
-          assertion = -> { expect(record).not_to disallow_value(100000).for(:attr) }
-          column_type_class = column_type_class_for(type)
-          message = <<-MESSAGE.strip_heredoc.strip
-            Did not expect errors when attr is set to 100000,
-            got RangeError: "100000 is out of range for #{column_type_class} with limit 2"
-          MESSAGE
-          expect(&assertion).to fail_with_message(message)
-        end
-
-        context 'qualified with a message' do
-          it 'ignores any specified message, failing with the correct message' do
-            type = :integer
-            attribute_options = { type: type, options: { limit: 2 } }
-            record = define_model(:example, attr: attribute_options).new
-            assertion = -> do
-              expect(record).
-                not_to disallow_value(100000).
-                for(:attr).
-                with_message('some message')
-            end
-            column_type_class = column_type_class_for(type)
-            message = <<-MESSAGE.strip_heredoc.strip
-              Did not expect errors to include "some message" when attr is set to 100000,
-              got RangeError: "100000 is out of range for #{column_type_class} with limit 2"
-            MESSAGE
-            expect(&assertion).to fail_with_message(message)
-          end
-        end
-      end
-
-      if active_model_supports_strict?
-        context 'qualified with strict' do
-          it 'accepts, failing with the correct message' do
-            type = :integer
-            attribute_options = { type: type, options: { limit: 2 } }
-            record = define_model(:example, attr: attribute_options).new
-            assertion = -> do
-              expect(record).
-                not_to disallow_value(100000).
-                for(:attr).
-                strict
-            end
-            column_type_class = column_type_class_for(type)
-            message = <<-MESSAGE.strip_heredoc.strip
-              Did not expect an exception to have been raised when attr is set to 100000,
-              got RangeError: "100000 is out of range for #{column_type_class} with limit 2"
-            MESSAGE
-            expect(&assertion).to fail_with_message(message)
-          end
-
-          context 'qualified with a message' do
-            it 'ignores any specified message' do
-              type = :integer
-              attribute_options = { type: type, options: { limit: 2 } }
-              record = define_model(:example, attr: attribute_options).new
-              assertion = -> do
-                expect(record).
-                  not_to disallow_value(100000).
-                  for(:attr).
-                  with_message('some message').
-                  strict
-              end
-              column_type_class = column_type_class_for(type)
-              message = <<-MESSAGE.strip_heredoc.strip
-                Did not expect exception to include "some message" when attr is set to 100000,
-                got RangeError: "100000 is out of range for #{column_type_class} with limit 2"
-              MESSAGE
-              expect(&assertion).to fail_with_message(message)
-            end
-          end
-        end
-      end
-    end
-  end
-
   def matcher(value)
     described_class.new(value)
   end

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

@@ -1,22 +1,19 @@
 require 'unit_spec_helper'
 
 describe Shoulda::Matchers::ActiveModel::NumericalityMatchers::ComparisonMatcher do
-  subject { described_class.new(matcher, 0, :>) }
-
-  it_behaves_like 'a numerical submatcher'
+  it_behaves_like 'a numerical submatcher' do
+    subject { build_matcher }
+  end
 
   shared_examples_for 'strict qualifier' do
-    def validation_qualifier
-      matcher_qualifier.to_s.gsub(/^is_/, '').to_sym
-    end
-
     context 'asserting strict validation when validating strictly' do
       it 'accepts' do
         record = instance_with_validations(
           validation_qualifier => 1,
           strict: true
         )
-        expect(record).to matcher.__send__(matcher_qualifier, 1).strict
+        matcher = build_matcher(operator: operator, value: 1).strict
+        expect(record).to matcher
       end
     end
 
@@ -27,209 +24,231 @@ describe Shoulda::Matchers::ActiveModel::NumericalityMatchers::ComparisonMatcher
           validation_qualifier => 1,
           strict: true
         )
-        expect(record).not_to matcher.__send__(matcher_qualifier, 1)
+        matcher = build_matcher(operator: operator, value: 1)
+        expect(record).not_to matcher
       end
     end
 
     context 'asserting strict validation when not validating strictly' do
       it 'rejects' do
         record = instance_with_validations(validation_qualifier => 1)
-        expect(record).not_to matcher.__send__(matcher_qualifier, 1).strict
+        matcher = build_matcher(operator: operator, value: 1).strict
+        expect(record).not_to matcher
       end
     end
   end
 
   context 'when initialized without correct numerical matcher' do
-    it 'raises an argument error' do
-      fake_matcher = matcher
-      class << fake_matcher
-        undef_method :diff_to_compare
-      end
-      expect do
-        described_class.new(fake_matcher, 0, :>)
-      end.to raise_error ArgumentError
+    it 'raises an ArgumentError' do
+      numericality_matcher = double
+      expect { described_class.new(numericality_matcher, 0, :>) }.
+        to raise_error(ArgumentError)
     end
   end
 
-  context 'is_greater_than' do
-    include_examples 'strict qualifier' do
-      def matcher_qualifier
-        :is_greater_than
-      end
-    end
+  describe 'is_greater_than' do
+    include_examples 'strict qualifier'
 
     it do
-      expect(instance_with_validations(greater_than: 2))
-        .to matcher.is_greater_than(2)
+      record = instance_with_validations(greater_than: 1.5)
+      matcher = build_matcher(operator: :>, value: 2)
+      expect(record).not_to matcher
     end
 
     it do
-      expect(instance_with_validations(greater_than: 1.5))
-        .not_to matcher.is_greater_than(2)
+      record = instance_with_validations(greater_than: 2)
+      matcher = build_matcher(operator: :>, value: 2)
+      expect(record).to matcher
     end
 
     it do
-      expect(instance_with_validations(greater_than: 2.5))
-        .not_to matcher.is_greater_than(2)
+      record = instance_with_validations(greater_than: 2.5)
+      matcher = build_matcher(operator: :>, value: 2)
+      expect(record).not_to matcher
     end
 
     it do
-      expect(instance_without_validations).not_to matcher.is_greater_than(2)
+      record = instance_without_validations
+      matcher = build_matcher(operator: :>, value: 2)
+      expect(record).not_to matcher
     end
-  end
 
-  context 'is_greater_than_or_equal_to' do
-    include_examples 'strict qualifier' do
-      def matcher_qualifier
-        :is_greater_than_or_equal_to
-      end
+    def operator
+      :>
+    end
+
+    def validation_qualifier
+      :greater_than
     end
+  end
+
+  describe 'is_greater_than_or_equal_to' do
+    include_examples 'strict qualifier'
 
     it do
-      expect(instance_with_validations(greater_than_or_equal_to: 2))
-        .to matcher.is_greater_than_or_equal_to(2)
+      record = instance_with_validations(greater_than_or_equal_to: 1.5)
+      matcher = build_matcher(operator: :>=, value: 2)
+      expect(record).not_to matcher
     end
 
     it do
-      expect(instance_with_validations(greater_than_or_equal_to: 1.5))
-        .not_to matcher.is_greater_than_or_equal_to(2)
+      record = instance_with_validations(greater_than_or_equal_to: 2)
+      matcher = build_matcher(operator: :>=, value: 2)
+      expect(record).to matcher
     end
 
     it do
-      expect(instance_with_validations(greater_than_or_equal_to: 2.5))
-        .not_to matcher.is_greater_than_or_equal_to(2)
+      record = instance_with_validations(greater_than_or_equal_to: 2.5)
+      matcher = build_matcher(operator: :>=, value: 2)
+      expect(record).not_to matcher
     end
 
     it do
-      expect(instance_without_validations)
-        .not_to matcher.is_greater_than_or_equal_to(2)
+      record = instance_without_validations
+      matcher = build_matcher(operator: :>=, value: 2)
+      expect(record).not_to matcher
     end
-  end
 
-  context 'is_less_than' do
-    include_examples 'strict qualifier' do
-      def matcher_qualifier
-        :is_less_than
-      end
+    def operator
+      :>=
     end
 
+    def validation_qualifier
+      :greater_than_or_equal_to
+    end
+  end
+
+  describe 'is_less_than' do
+    include_examples 'strict qualifier'
+
     it do
-      expect(instance_with_validations(less_than: 2))
-        .to matcher.is_less_than(2)
+      record = instance_with_validations(less_than: 1.5)
+      matcher = build_matcher(operator: :<, value: 2)
+      expect(record).not_to matcher
     end
 
     it do
-      expect(instance_with_validations(less_than: 1.5))
-        .not_to matcher.is_less_than(2)
+      record = instance_with_validations(less_than: 2)
+      matcher = build_matcher(operator: :<, value: 2)
+      expect(record).to matcher
     end
 
     it do
-      expect(instance_with_validations(less_than: 2.5))
-        .not_to matcher.is_less_than(2)
+      record = instance_with_validations(less_than: 2.5)
+      matcher = build_matcher(operator: :<, value: 2)
+      expect(record).not_to matcher
     end
 
     it do
-      expect(instance_without_validations)
-        .not_to matcher.is_less_than(2)
+      record = instance_without_validations
+      matcher = build_matcher(operator: :<, value: 2)
+      expect(record).not_to matcher
     end
-  end
 
-  context 'is_less_than_or_equal_to' do
-    include_examples 'strict qualifier' do
-      def matcher_qualifier
-        :is_less_than_or_equal_to
-      end
+    def operator
+      :<
     end
 
+    def validation_qualifier
+      :less_than
+    end
+  end
+
+  describe 'is_less_than_or_equal_to' do
+    include_examples 'strict qualifier'
+
     it do
-      expect(instance_with_validations(less_than_or_equal_to: 2))
-        .to matcher.is_less_than_or_equal_to(2)
+      record = instance_with_validations(less_than_or_equal_to: 1.5)
+      matcher = build_matcher(operator: :<=, value: 2)
+      expect(record).not_to matcher
     end
 
     it do
-      expect(instance_with_validations(less_than_or_equal_to: 1.5))
-        .not_to matcher.is_less_than_or_equal_to(2)
+      record = instance_with_validations(less_than_or_equal_to: 2)
+      matcher = build_matcher(operator: :<=, value: 2)
+      expect(record).to matcher
     end
 
     it do
-      expect(instance_with_validations(less_than_or_equal_to: 2.5))
-        .not_to matcher.is_less_than_or_equal_to(2)
+      record = instance_with_validations(less_than_or_equal_to: 2.5)
+      matcher = build_matcher(operator: :<=, value: 2)
+      expect(record).not_to matcher
     end
 
     it do
-      expect(instance_without_validations)
-        .not_to matcher.is_less_than_or_equal_to(2)
+      record = instance_without_validations
+      matcher = build_matcher(operator: :<=, value: 2)
+      expect(record).not_to matcher
     end
-  end
 
-  context 'is_equal_to' do
-    include_examples 'strict qualifier' do
-      def matcher_qualifier
-        :is_equal_to
-      end
+    def operator
+      :<=
     end
 
-    it do
-      expect(instance_with_validations(equal_to: 0))
-        .to matcher.is_equal_to(0)
+    def validation_qualifier
+      :less_than_or_equal_to
     end
+  end
+
+  describe 'is_equal_to' do
+    include_examples 'strict qualifier'
 
     it do
-      expect(instance_with_validations(equal_to: -0.5))
-        .not_to matcher.is_equal_to(0)
+      record = instance_with_validations(equal_to: 1.5)
+      matcher = build_matcher(operator: :==, value: 2)
+      expect(record).not_to matcher
     end
 
     it do
-      expect(instance_with_validations(equal_to: 0.5))
-        .not_to matcher.is_equal_to(0)
+      record = instance_with_validations(equal_to: 2)
+      matcher = build_matcher(operator: :==, value: 2)
+      expect(record).to matcher
     end
 
     it do
-      expect(instance_without_validations)
-        .not_to matcher.is_equal_to(0)
+      record = instance_with_validations(equal_to: 2.5)
+      matcher = build_matcher(operator: :==, value: 2)
+      expect(record).not_to matcher
     end
-  end
 
-  context 'with_message' do
-    it 'verifies the message for the validation' do
-      instance = instance_with_validations(equal_to: 0, message: 'Must be zero')
-      expect(instance).to matcher.is_equal_to(0).with_message('Must be zero')
+    it do
+      record = instance_without_validations
+      matcher = build_matcher(operator: :==, value: 2)
+      expect(record).not_to matcher
     end
-  end
 
-  context 'qualified with on and validating with on' do
-    it 'accepts' do
-      expect(instance_with_validations(on: :customizable)).
-        to matcher.on(:customizable)
+    def operator
+      :==
     end
-  end
 
-  context 'qualified with on but not validating with on' do
-    it 'accepts since the validation never considers a context' do
-      expect(instance_with_validations).to matcher.on(:customizable)
+    def validation_qualifier
+      :equal_to
     end
   end
 
-  context 'not qualified with on but validating with on' do
-    it 'rejects since the validation never runs' do
-      expect(instance_with_validations(on: :customizable)).
-        not_to matcher
+  describe 'with_message' do
+    it 'verifies the message for the validation' do
+      instance = instance_with_validations(equal_to: 0, message: 'Must be zero')
+      matcher = build_matcher.with_message('Must be zero')
+      expect(instance).to matcher
     end
   end
 
   describe '#comparison_description' do
-    [{ operator: :>, value: 0, expectation: 'greater than 0' },
-     { operator: :>=, value: -1.0, expectation: 'greater than or equal to -1.0' },
-     { operator: :==, value: 2.2, expectation: 'equal to 2.2' },
-     { operator: :<, value: -3, expectation: 'less than -3' },
-     { operator: :<=, value: 4, expectation: 'less than or equal to 4' },
-    ].each do |h|
-      context "with :#{h[:operator]} as operator and #{h[:value]} as value" do
-        subject do
-          described_class.new(matcher, h[:value], h[:operator])
-            .comparison_description
+    tests = [
+      { operator: :>, value: 0, expectation: 'greater than 0' },
+      { operator: :>=, value: -1.0, expectation: 'greater than or equal to -1.0' },
+      { operator: :==, value: 2.2, expectation: 'equal to 2.2' },
+      { operator: :<, value: -3, expectation: 'less than -3' },
+      { operator: :<=, value: 4, expectation: 'less than or equal to 4' },
+    ]
+
+    tests.each do |test|
+      context "with :#{test[:operator]} as operator and #{test[:value]} as value" do
+        it do
+          matcher = build_matcher(operator: test[:operator], value: test[:value])
+          expect(matcher.comparison_description).to eq test[:expectation]
         end
-        it { should eq h[:expectation] }
       end
     end
   end
@@ -245,17 +264,25 @@ describe Shoulda::Matchers::ActiveModel::NumericalityMatchers::ComparisonMatcher
     model_with_validations(options).new(attribute_name => '1')
   end
 
-  def instance_without_validations
+  def model_without_validations
     define_model :example, attribute_name => :string do |model|
       model.attr_accessible(attribute_name)
-    end.new
+    end
+  end
+
+  def instance_without_validations
+    model_without_validations.new
   end
 
   def attribute_name
     :attr
   end
 
-  def matcher
-    validate_numericality_of(:attr)
+  def build_matcher(operator: :==, value: 0)
+    described_class.new(numericality_matcher, value, operator).for(attribute_name)
+  end
+
+  def numericality_matcher
+    double(diff_to_compare: 1)
   end
 end