shoulda-matchers 2.8.0 → 3.0.0.rc1

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

@@ -1,5 +1,13 @@
 require 'unit_spec_helper'
 
+describe Shoulda::Matchers::ActiveModel do
+  describe '#allow_values' do
+    it 'is aliased to #allow_value' do
+      expect(method(:allow_values)).to eq(method(:allow_value))
+    end
+  end
+end
+
 describe Shoulda::Matchers::ActiveModel::AllowValueMatcher, type: :model do
   context "#description" do
     it 'describes itself with multiple values' do
@@ -165,24 +173,29 @@ describe Shoulda::Matchers::ActiveModel::AllowValueMatcher, type: :model do
           less_than_or_equal_to: 50000
       end.new
     end
+
     bad_values = [nil, '', 'abc', '0', '50001', '123456', []]
 
-    it 'allows a good value' do
+    it 'matches given a good value' do
       expect(model).to allow_value('12345').for(:attr)
     end
 
-    bad_values.each do |bad_value|
-      it "rejects a bad value (#{bad_value.inspect})" 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)
       end
     end
 
-    it "rejects several bad values (#{bad_values.map(&:inspect).join(', ')})" do
+    it 'does not match given multiple bad values' do
       expect(model).not_to allow_value(*bad_values).for(:attr)
     end
 
-    it "rejects a mix of both good and bad values" do
-      expect(model).not_to allow_value('12345', *bad_values).for(:attr)
+    it "does not match given good values along with bad values" do
+      message = %{Expected errors when attr is set to "12345",\ngot no errors}
+
+      expect {
+        expect(model).not_to allow_value('12345', *bad_values).for(:attr)
+      }.to fail_with_message(message)
     end
   end
 
@@ -232,19 +245,22 @@ describe Shoulda::Matchers::ActiveModel::AllowValueMatcher, type: :model do
     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
-          attribute_options = { type: :integer, options: { limit: 2 } }
+          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 ActiveRecord::Type::Integer with limit 2"
+            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
-            attribute_options = { type: :integer, options: { limit: 2 } }
+            type = :integer
+            attribute_options = { type: type, options: { limit: 2 } }
             record = define_model(:example, attr: attribute_options).new
             assertion = -> do
               expect(record).
@@ -252,9 +268,10 @@ describe Shoulda::Matchers::ActiveModel::AllowValueMatcher, type: :model do
                 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 ActiveRecord::Type::Integer with limit 2"
+              got RangeError: "100000 is out of range for #{column_type_class} with limit 2"
             MESSAGE
             expect(&assertion).to fail_with_message(message)
           end
@@ -264,7 +281,8 @@ describe Shoulda::Matchers::ActiveModel::AllowValueMatcher, type: :model do
       if active_model_supports_strict?
         context 'qualified with strict' do
           it 'rejects, failing with the correct message' do
-            attribute_options = { type: :integer, options: { limit: 2 } }
+            type = :integer
+            attribute_options = { type: type, options: { limit: 2 } }
             record = define_model(:example, attr: attribute_options).new
             assertion = -> do
               expect(record).
@@ -272,16 +290,18 @@ describe Shoulda::Matchers::ActiveModel::AllowValueMatcher, type: :model do
                 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 ActiveRecord::Type::Integer with limit 2"
+              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
-              attribute_options = { type: :integer, options: { limit: 2 } }
+              type = :integer
+              attribute_options = { type: type, options: { limit: 2 } }
               record = define_model(:example, attr: attribute_options).new
               assertion = -> do
                 expect(record).
@@ -290,9 +310,10 @@ describe Shoulda::Matchers::ActiveModel::AllowValueMatcher, type: :model do
                   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 ActiveRecord::Type::Integer with limit 2"
+                got RangeError: "100000 is out of range for #{column_type_class} with limit 2"
               MESSAGE
               expect(&assertion).to fail_with_message(message)
             end
@@ -301,4 +322,50 @@ describe Shoulda::Matchers::ActiveModel::AllowValueMatcher, type: :model do
       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
+
+          def name=(_value)
+            nil
+          end
+        end
+
+        assertion = -> {
+          expect(model.new).to allow_value('anything').for(:name)
+        }
+
+        expect(&assertion).to raise_error(
+          Shoulda::Matchers::ActiveModel::AllowValueMatcher::CouldNotSetAttributeError
+        )
+      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
+
+          def name=(value)
+            @name = value unless value.nil?
+          end
+        end
+
+        record = model.new(name: 'some name')
+
+        assertion = -> {
+          expect(record).to allow_value(nil).for(:name)
+        }
+
+        expect(&assertion).to raise_error(
+          Shoulda::Matchers::ActiveModel::AllowValueMatcher::CouldNotSetAttributeError
+        )
+      end
+    end
+  end
 end

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

@@ -83,19 +83,22 @@ describe Shoulda::Matchers::ActiveModel::DisallowValueMatcher, type: :model do
     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
-          attribute_options = { type: :integer, options: { limit: 2 } }
+          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 ActiveRecord::Type::Integer with limit 2"
+            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
-            attribute_options = { type: :integer, options: { limit: 2 } }
+            type = :integer
+            attribute_options = { type: type, options: { limit: 2 } }
             record = define_model(:example, attr: attribute_options).new
             assertion = -> do
               expect(record).
@@ -103,9 +106,10 @@ describe Shoulda::Matchers::ActiveModel::DisallowValueMatcher, type: :model do
                 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 ActiveRecord::Type::Integer with limit 2"
+              got RangeError: "100000 is out of range for #{column_type_class} with limit 2"
             MESSAGE
             expect(&assertion).to fail_with_message(message)
           end
@@ -115,7 +119,8 @@ describe Shoulda::Matchers::ActiveModel::DisallowValueMatcher, type: :model do
       if active_model_supports_strict?
         context 'qualified with strict' do
           it 'accepts, failing with the correct message' do
-            attribute_options = { type: :integer, options: { limit: 2 } }
+            type = :integer
+            attribute_options = { type: type, options: { limit: 2 } }
             record = define_model(:example, attr: attribute_options).new
             assertion = -> do
               expect(record).
@@ -123,16 +128,18 @@ describe Shoulda::Matchers::ActiveModel::DisallowValueMatcher, type: :model do
                 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 ActiveRecord::Type::Integer with limit 2"
+              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
-              attribute_options = { type: :integer, options: { limit: 2 } }
+              type = :integer
+              attribute_options = { type: type, options: { limit: 2 } }
               record = define_model(:example, attr: attribute_options).new
               assertion = -> do
                 expect(record).
@@ -141,9 +148,10 @@ describe Shoulda::Matchers::ActiveModel::DisallowValueMatcher, type: :model do
                   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 ActiveRecord::Type::Integer with limit 2"
+                got RangeError: "100000 is out of range for #{column_type_class} with limit 2"
               MESSAGE
               expect(&assertion).to fail_with_message(message)
             end

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

@@ -5,6 +5,40 @@ describe Shoulda::Matchers::ActiveModel::NumericalityMatchers::ComparisonMatcher
 
   it_behaves_like 'a numerical submatcher'
 
+  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
+      end
+    end
+
+    context 'asserting non-strict validation when validating strictly' do
+      it 'rejects' do
+        pending 'This needs to be fixed'
+        record = instance_with_validations(
+          validation_qualifier => 1,
+          strict: true
+        )
+        expect(record).not_to matcher.__send__(matcher_qualifier, 1)
+      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
+      end
+    end
+  end
+
   context 'when initialized without correct numerical matcher' do
     it 'raises an argument error' do
       fake_matcher = matcher
@@ -18,6 +52,12 @@ describe Shoulda::Matchers::ActiveModel::NumericalityMatchers::ComparisonMatcher
   end
 
   context 'is_greater_than' do
+    include_examples 'strict qualifier' do
+      def matcher_qualifier
+        :is_greater_than
+      end
+    end
+
     it do
       expect(instance_with_validations(greater_than: 2))
         .to matcher.is_greater_than(2)
@@ -38,7 +78,13 @@ describe Shoulda::Matchers::ActiveModel::NumericalityMatchers::ComparisonMatcher
     end
   end
 
-  context 'greater_than_or_equal_to' do
+  context 'is_greater_than_or_equal_to' do
+    include_examples 'strict qualifier' do
+      def matcher_qualifier
+        :is_greater_than_or_equal_to
+      end
+    end
+
     it do
       expect(instance_with_validations(greater_than_or_equal_to: 2))
         .to matcher.is_greater_than_or_equal_to(2)
@@ -60,7 +106,13 @@ describe Shoulda::Matchers::ActiveModel::NumericalityMatchers::ComparisonMatcher
     end
   end
 
-  context 'less_than' do
+  context 'is_less_than' do
+    include_examples 'strict qualifier' do
+      def matcher_qualifier
+        :is_less_than
+      end
+    end
+
     it do
       expect(instance_with_validations(less_than: 2))
         .to matcher.is_less_than(2)
@@ -82,7 +134,13 @@ describe Shoulda::Matchers::ActiveModel::NumericalityMatchers::ComparisonMatcher
     end
   end
 
-  context 'less_than_or_equal_to' do
+  context 'is_less_than_or_equal_to' do
+    include_examples 'strict qualifier' do
+      def matcher_qualifier
+        :is_less_than_or_equal_to
+      end
+    end
+
     it do
       expect(instance_with_validations(less_than_or_equal_to: 2))
         .to matcher.is_less_than_or_equal_to(2)
@@ -105,6 +163,12 @@ describe Shoulda::Matchers::ActiveModel::NumericalityMatchers::ComparisonMatcher
   end
 
   context 'is_equal_to' do
+    include_examples 'strict qualifier' do
+      def matcher_qualifier
+        :is_equal_to
+      end
+    end
+
     it do
       expect(instance_with_validations(equal_to: 0))
         .to matcher.is_equal_to(0)
@@ -133,6 +197,26 @@ describe Shoulda::Matchers::ActiveModel::NumericalityMatchers::ComparisonMatcher
     end
   end
 
+  context 'qualified with on and validating with on' do
+    it 'accepts' do
+      expect(instance_with_validations(on: :customizable)).
+        to matcher.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(instance_with_validations).to matcher.on(:customizable)
+    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
+    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' },
@@ -150,19 +234,27 @@ describe Shoulda::Matchers::ActiveModel::NumericalityMatchers::ComparisonMatcher
     end
   end
 
+  def model_with_validations(options = {})
+    define_model :example, attribute_name => :string do |model|
+      model.validates_numericality_of(attribute_name, options)
+      model.attr_accessible(attribute_name)
+    end
+  end
+
   def instance_with_validations(options = {})
-    define_model :example, attr: :string do
-      validates_numericality_of :attr, options
-      attr_accessible :attr
-    end.new
+    model_with_validations(options).new(attribute_name => '1')
   end
 
   def instance_without_validations
-    define_model :example, attr: :string do
-      attr_accessible :attr
+    define_model :example, attribute_name => :string do |model|
+      model.attr_accessible(attribute_name)
     end.new
   end
 
+  def attribute_name
+    :attr
+  end
+
   def matcher
     validate_numericality_of(:attr)
   end

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

@@ -45,6 +45,44 @@ describe Shoulda::Matchers::ActiveModel::NumericalityMatchers::EvenNumberMatcher
     end
   end
 
+  context 'asserting strict validation when validating strictly' do
+    it 'accepts' do
+      expect(validating_even_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_even_number(strict: true)).not_to subject
+    end
+  end
+
+  context 'asserting strict validation when not validating strictly' do
+    it 'rejects' do
+      expect(validating_even_number).not_to subject.strict
+    end
+  end
+
+  context 'qualified with on and validating with on' do
+    it 'accepts' do
+      expect(validating_even_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_even_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_even_number(on: :customizable)).
+        not_to subject
+    end
+  end
 
   def validating_even_number(options = {})
     define_model :example, attr: :string do
@@ -56,4 +94,4 @@ describe Shoulda::Matchers::ActiveModel::NumericalityMatchers::EvenNumberMatcher
     define_model(:example, attr: :string).new
   end
 
-end
+end