shoulda-matchers 3.0.0 → 3.0.1

data/gemfiles/4.2.gemfile

@@ -7,8 +7,7 @@ gem "bundler", "~> 1.1"
 gem "pry", :github => "pry/pry"
 gem "pry-byebug"
 gem "rake", "~> 10.0"
-gem "rspec-core", ">= 3.2.0", "< 4"
-gem "rspec-expectations", ">= 3.2.0", "< 4"
+gem "rspec", "~> 3.2"
 gem "yard"
 gem "redcarpet"
 gem "pygments.rb"

data/gemfiles/4.2.gemfile.lock

@@ -141,6 +141,10 @@ GEM
     rake (10.4.2)
     rdoc (4.2.0)
     redcarpet (3.3.2)
+    rspec (3.3.0)
+      rspec-core (~> 3.3.0)
+      rspec-expectations (~> 3.3.0)
+      rspec-mocks (~> 3.3.0)
     rspec-core (3.3.2)
       rspec-support (~> 3.3.0)
     rspec-expectations (3.3.1)
@@ -219,8 +223,7 @@ DEPENDENCIES
   rails (~> 4.2.0)
   rake (~> 10.0)
   redcarpet
-  rspec-core (>= 3.2.0, < 4)
-  rspec-expectations (>= 3.2.0, < 4)
+  rspec (~> 3.2)
   rspec-rails (>= 3.2.0, < 4)
   sass-rails (~> 5.0)
   sdoc (~> 0.4.0)

data/lib/shoulda/matchers/action_controller/respond_with_matcher.rb

@@ -133,11 +133,7 @@ module Shoulda
           when :missing  then 404
           when :error    then 500..599
           when Symbol
-            if defined?(::Rack::Utils::SYMBOL_TO_STATUS_CODE)
-              ::Rack::Utils::SYMBOL_TO_STATUS_CODE[potential_symbol]
-            else
-              ::ActionController::Base::SYMBOL_TO_STATUS_CODE[potential_symbol]
-            end
+            ::Rack::Utils::SYMBOL_TO_STATUS_CODE[potential_symbol]
           else
             potential_symbol
           end

data/lib/shoulda/matchers/active_model/allow_value_matcher.rb

@@ -91,9 +91,9 @@ module Shoulda
       #           end
       #         end
       #
-      # * You're attempting to assert that an numeric attribute should not allow a
-      #   string that contains non-numeric characters, yet the writer method for
-      #   that attribute strips out non-numeric characters:
+      # * You're attempting to assert that a numeric attribute should not allow
+      #   a string that contains non-numeric characters, yet the writer method
+      #   for that attribute strips out non-numeric characters:
       #
       #         class Foo
       #           include ActiveModel::Model
@@ -326,7 +326,29 @@ module Shoulda
           attr_accessor :model, :attribute, :expected_value, :actual_value
 
           def message
-            "Expected #{model.class} to be able to set #{attribute} to #{expected_value.inspect}, but got #{actual_value.inspect} instead."
+            Shoulda::Matchers.word_wrap <<-MESSAGE
+The allow_value matcher attempted to set :#{attribute} on #{model.name} to
+#{expected_value.inspect}, but when the attribute was read back, it
+had stored #{actual_value.inspect} instead.
+
+This creates a problem because it means that the model is behaving in a way that
+is interfering with the test -- there's a mismatch between the test that was
+written and test that was actually run.
+
+There are a couple of reasons why this could be happening:
+
+* The writer method for :#{attribute} has been overridden and contains custom
+  logic to prevent certain values from being set or change which values are
+  stored.
+* ActiveRecord is typecasting the incoming value.
+
+Regardless, the fact you're seeing this message usually indicates a larger
+problem. Please file an issue on the GitHub repo for shoulda-matchers,
+including details about your model and the test you've written, and we can point
+you in the right direction:
+
+https://github.com/thoughtbot/shoulda-matchers/issues
+            MESSAGE
           end
         end
 

data/lib/shoulda/matchers/active_model/numericality_matchers/comparison_matcher.rb

@@ -20,7 +20,6 @@ module Shoulda
             @value = value
             @operator = operator
             @message = ERROR_MESSAGES[operator]
-            @comparison_combos = comparison_combos
             @strict = false
           end
 
@@ -80,11 +79,7 @@ module Shoulda
           def submatchers
             @_submatchers ||=
               comparison_combos.map do |diff, submatcher_method_name|
-                matcher = __send__(
-                  submatcher_method_name,
-                  (@value + diff).to_s,
-                  nil
-                )
+                matcher = __send__(submatcher_method_name, diff, nil)
                 matcher.with_message(@message, values: { count: @value })
                 matcher
               end
@@ -127,8 +122,14 @@ module Shoulda
           end
 
           def diffs_to_compare
-            diff = @numericality_matcher.diff_to_compare
-            [-diff, 0, diff]
+            diff_to_compare = @numericality_matcher.diff_to_compare
+            values = [-1, 0, 1].map { |sign| @value + (diff_to_compare * sign) }
+
+            if @numericality_matcher.given_numeric_column?
+              values
+            else
+              values.map(&:to_s)
+            end
           end
 
           def comparison_expectation

data/lib/shoulda/matchers/active_model/numericality_matchers/even_number_matcher.rb

@@ -6,14 +6,6 @@ module Shoulda
         class EvenNumberMatcher < NumericTypeMatcher
           NON_EVEN_NUMBER_VALUE = 1
 
-          def initialize(attribute, options = {})
-            @attribute = attribute
-            @disallow_value_matcher =
-              DisallowValueMatcher.new(NON_EVEN_NUMBER_VALUE.to_s).
-              for(@attribute).
-              with_message(:even)
-          end
-
           def allowed_type
             'even numbers'
           end
@@ -21,6 +13,20 @@ module Shoulda
           def diff_to_compare
             2
           end
+
+          protected
+
+          def wrap_disallow_value_matcher(matcher)
+            matcher.with_message(:even)
+          end
+
+          def disallowed_value
+            if @numeric_type_matcher.given_numeric_column?
+              NON_EVEN_NUMBER_VALUE
+            else
+              NON_EVEN_NUMBER_VALUE.to_s
+            end
+          end
         end
       end
     end

data/lib/shoulda/matchers/active_model/numericality_matchers/numeric_type_matcher.rb

@@ -1,29 +1,37 @@
+require 'forwardable'
+
 module Shoulda
   module Matchers
     module ActiveModel
       module NumericalityMatchers
         # @private
         class NumericTypeMatcher
-          def initialize
-            raise NotImplementedError
-          end
+          extend Forwardable
+
+          def_delegators :disallow_value_matcher, :matches?, :failure_message,
+            :failure_message_when_negated
 
-          def matches?(subject)
-            @disallow_value_matcher.matches?(subject)
+          def initialize(numeric_type_matcher, attribute, options = {})
+            @numeric_type_matcher = numeric_type_matcher
+            @attribute = attribute
+            @options = options
+            @message = nil
+            @context = nil
+            @strict = false
           end
 
           def with_message(message)
-            @disallow_value_matcher.with_message(message)
+            @message = message
             self
           end
 
           def strict
-            @disallow_value_matcher.strict
+            @strict = true
             self
           end
 
           def on(context)
-            @disallow_value_matcher.on(context)
+            @context = context
             self
           end
 
@@ -35,12 +43,39 @@ module Shoulda
             raise NotImplementedError
           end
 
-          def failure_message
-            @disallow_value_matcher.failure_message
+          protected
+
+          attr_reader :attribute
+
+          def wrap_disallow_value_matcher(matcher)
+            raise NotImplementedError
+          end
+
+          def disallowed_value
+            raise NotImplementedError
           end
 
-          def failure_message_when_negated
-            @disallow_value_matcher.failure_message_when_negated
+          private
+
+          def disallow_value_matcher
+            @_disallow_value_matcher ||= begin
+              DisallowValueMatcher.new(disallowed_value).tap do |matcher|
+                matcher.for(attribute)
+                wrap_disallow_value_matcher(matcher)
+
+                if @message
+                  matcher.with_message(@message)
+                end
+
+                if @strict
+                  matcher.strict
+                end
+
+                if @context
+                  matcher.on(@context)
+                end
+              end
+            end
           end
         end
       end

data/lib/shoulda/matchers/active_model/numericality_matchers/odd_number_matcher.rb

@@ -4,15 +4,7 @@ module Shoulda
       module NumericalityMatchers
         # @private
         class OddNumberMatcher < NumericTypeMatcher
-          NON_ODD_NUMBER_VALUE  = 2
-
-          def initialize(attribute, options = {})
-            @attribute = attribute
-            @disallow_value_matcher =
-              DisallowValueMatcher.new(NON_ODD_NUMBER_VALUE.to_s).
-              for(@attribute).
-              with_message(:odd)
-          end
+          NON_ODD_NUMBER_VALUE = 2
 
           def allowed_type
             'odd numbers'
@@ -21,6 +13,20 @@ module Shoulda
           def diff_to_compare
             2
           end
+
+          protected
+
+          def wrap_disallow_value_matcher(matcher)
+            matcher.with_message(:odd)
+          end
+
+          def disallowed_value
+            if @numeric_type_matcher.given_numeric_column?
+              NON_ODD_NUMBER_VALUE
+            else
+              NON_ODD_NUMBER_VALUE.to_s
+            end
+          end
         end
       end
     end

data/lib/shoulda/matchers/active_model/numericality_matchers/only_integer_matcher.rb

@@ -5,13 +5,6 @@ module Shoulda
         # @private
         class OnlyIntegerMatcher < NumericTypeMatcher
           NON_INTEGER_VALUE = 0.1
-          def initialize(attribute)
-            @attribute = attribute
-            @disallow_value_matcher =
-              DisallowValueMatcher.new(NON_INTEGER_VALUE.to_s).
-              for(attribute).
-              with_message(:not_an_integer)
-          end
 
           def allowed_type
             'integers'
@@ -20,6 +13,20 @@ module Shoulda
           def diff_to_compare
             1
           end
+
+          protected
+
+          def wrap_disallow_value_matcher(matcher)
+            matcher.with_message(:not_an_integer)
+          end
+
+          def disallowed_value
+            if @numeric_type_matcher.given_numeric_column?
+              NON_INTEGER_VALUE
+            else
+              NON_INTEGER_VALUE.to_s
+            end
+          end
         end
       end
     end

data/lib/shoulda/matchers/active_model/validate_inclusion_of_matcher.rb

@@ -263,9 +263,12 @@ module Shoulda
 
       # @private
       class ValidateInclusionOfMatcher < ValidationMatcher
-        ARBITRARY_OUTSIDE_STRING = 'shouldamatchersteststring'
+        ARBITRARY_OUTSIDE_STRING = 'shoulda-matchers test string'
         ARBITRARY_OUTSIDE_FIXNUM = 123456789
         ARBITRARY_OUTSIDE_DECIMAL = BigDecimal.new('0.123456789')
+        ARBITRARY_OUTSIDE_DATE = Date.jd(9999999)
+        ARBITRARY_OUTSIDE_DATETIME = DateTime.jd(9999999)
+        ARBITRARY_OUTSIDE_TIME = Time.at(9999999999)
         BOOLEAN_ALLOWS_BOOLEAN_MESSAGE = <<EOT
 You are using `validate_inclusion_of` to assert that a boolean column allows
 boolean values and disallows non-boolean ones. Be aware that it is not possible
@@ -447,6 +450,12 @@ EOT
             [ARBITRARY_OUTSIDE_FIXNUM]
           when :decimal
             [ARBITRARY_OUTSIDE_DECIMAL]
+          when :date
+            [ARBITRARY_OUTSIDE_DATE]
+          when :datetime
+            [ARBITRARY_OUTSIDE_DATETIME]
+          when :time
+            [ARBITRARY_OUTSIDE_TIME]
           else
             [ARBITRARY_OUTSIDE_STRING]
           end
@@ -492,9 +501,9 @@ EOT
 
         def column_type_to_attribute_type(type)
           case type
-            when :boolean, :decimal then type
             when :integer, :float then :fixnum
-            else :default
+            when :timestamp then :datetime
+            else type
           end
         end
 
@@ -503,7 +512,10 @@ EOT
             when true, false then :boolean
             when BigDecimal then :decimal
             when Fixnum then :fixnum
-            else :default
+            when Date then :date
+            when DateTime then :datetime
+            when Time then :time
+            else :unknown
           end
         end
       end

data/lib/shoulda/matchers/active_model/validate_numericality_of_matcher.rb

@@ -179,7 +179,7 @@ module Shoulda
       #
       # ##### is_greater_than
       #
-      # Use `is_greater_than` to test usage of tthe `:greater_than` option.
+      # Use `is_greater_than` to test usage of the `:greater_than` option.
       # This asserts that the attribute can take a number which is greater than
       # the given value and cannot take a number less than or equal to it.
       #
@@ -315,18 +315,19 @@ module Shoulda
           @submatchers = []
           @diff_to_compare = DEFAULT_DIFF_TO_COMPARE
           @strict = false
+
           add_disallow_value_matcher
         end
 
         def strict
-          @submatchers.each(&:strict)
           @strict = true
+          @submatchers.each(&:strict)
           self
         end
 
         def only_integer
           prepare_submatcher(
-            NumericalityMatchers::OnlyIntegerMatcher.new(@attribute)
+            NumericalityMatchers::OnlyIntegerMatcher.new(self, @attribute)
           )
           self
         end
@@ -342,14 +343,14 @@ module Shoulda
 
         def odd
           prepare_submatcher(
-            NumericalityMatchers::OddNumberMatcher.new(@attribute)
+            NumericalityMatchers::OddNumberMatcher.new(self, @attribute)
           )
           self
         end
 
         def even
           prepare_submatcher(
-            NumericalityMatchers::EvenNumberMatcher.new(@attribute)
+            NumericalityMatchers::EvenNumberMatcher.new(self, @attribute)
           )
           self
         end
@@ -391,6 +392,19 @@ module Shoulda
 
         def matches?(subject)
           @subject = subject
+
+          if given_numeric_column?
+            remove_disallow_value_matcher
+          end
+
+          if @submatchers.empty?
+            raise IneffectiveTestError.create(
+              model: @subject.class,
+              attribute: @attribute,
+              column_type: column_type
+            )
+          end
+
           first_failing_submatcher.nil?
         end
 
@@ -417,8 +431,18 @@ module Shoulda
           first_failing_submatcher.failure_message_when_negated
         end
 
+        def given_numeric_column?
+          [:integer, :float, :decimal].include?(column_type)
+        end
+
         private
 
+        def column_type
+          if @subject.class.respond_to?(:columns_hash)
+            @subject.class.columns_hash[@attribute.to_s].type
+          end
+        end
+
         def add_disallow_value_matcher
           disallow_value_matcher = DisallowValueMatcher.new(NON_NUMERIC_VALUE).
             for(@attribute).
@@ -427,8 +451,13 @@ module Shoulda
           add_submatcher(disallow_value_matcher)
         end
 
+        def remove_disallow_value_matcher
+          @submatchers.shift
+        end
+
         def prepare_submatcher(submatcher)
           add_submatcher(submatcher)
+
           if submatcher.respond_to?(:diff_to_compare)
             update_diff_to_compare(submatcher)
           end
@@ -476,6 +505,39 @@ module Shoulda
             arr
           end
         end
+
+        class IneffectiveTestError < Shoulda::Matchers::Error
+          attr_accessor :model, :attribute, :column_type
+
+          def message
+            Shoulda::Matchers.word_wrap <<-MESSAGE
+You are attempting to use validate_numericality_of, but the attribute you're
+testing, :#{attribute}, is #{a_or_an(column_type)} column. One of the things
+that the numericality matcher does is to assert that setting :#{attribute} to a
+string that doesn't look like #{a_or_an(column_type)} will cause your
+#{humanized_model_name} to become invalid. In this case, it's impossible to make
+this assertion since :#{attribute} will typecast any incoming value to
+#{a_or_an(column_type)}. This means that it's already guaranteed to be numeric!
+Since this matcher isn't doing anything, you can remove it from your model
+tests, and in fact, you can remove the validation from your model as it isn't
+doing anything either.
+            MESSAGE
+          end
+
+          private
+
+          def humanized_model_name
+            model.name.humanize.downcase
+          end
+
+          def a_or_an(next_word)
+            if next_word =~ /[aeiou]/
+              "an #{next_word}"
+            else
+              "a #{next_word}"
+            end
+          end
+        end
       end
     end
   end