shoulda-matchers 2.6.0 → 2.6.1.rc1

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

@@ -1,7 +1,13 @@
+require 'forwardable'
+
 module Shoulda # :nodoc:
   module Matchers
     module ActiveModel # :nodoc:
       class DisallowValueMatcher # :nodoc:
+        extend Forwardable
+
+        def_delegators :allow_matcher, :_after_setting_value
+
         def initialize(value)
           @allow_matcher = AllowValueMatcher.new(value)
         end
@@ -39,6 +45,10 @@ module Shoulda # :nodoc:
           @allow_matcher.strict
           self
         end
+
+        private
+
+        attr_reader :allow_matcher
       end
     end
   end

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

@@ -1,3 +1,5 @@
+require 'bigdecimal'
+
 module Shoulda # :nodoc:
   module Matchers
     module ActiveModel # :nodoc:
@@ -24,7 +26,7 @@ module Shoulda # :nodoc:
       class EnsureInclusionOfMatcher < ValidationMatcher # :nodoc:
         ARBITRARY_OUTSIDE_STRING = 'shouldamatchersteststring'
         ARBITRARY_OUTSIDE_FIXNUM = 123456789
-        ARBITRARY_OUTSIDE_DECIMAL = 0.123456789
+        ARBITRARY_OUTSIDE_DECIMAL = BigDecimal.new('0.123456789')
         BOOLEAN_ALLOWS_BOOLEAN_MESSAGE = <<EOT
 You are using `ensure_inclusion_of` to assert that a boolean column allows
 boolean values and disallows non-boolean ones. Assuming you are using
@@ -38,11 +40,6 @@ You are using `ensure_inclusion_of` to assert that a boolean column allows nil.
 Be aware that it is not possible to fully test this, as anything other than
 true, false or nil will be converted to false. Hence, you should consider
 removing this test and the corresponding validation.
-EOT
-        BOOLEAN_ALLOWS_NIL_WITH_NOT_NULL_MESSAGE = <<EOT
-You have specified that your model's #{@attribute} should ensure inclusion of nil.
-However, #{@attribute} is a boolean column which does not allow null values.
-Hence, this test will fail and there is no way to make it pass.
 EOT
 
         def initialize(attribute)
@@ -100,13 +97,9 @@ EOT
           if @range
             @low_message  ||= :inclusion
             @high_message ||= :inclusion
-
-            disallows_lower_value &&
-              allows_minimum_value &&
-              disallows_higher_value &&
-              allows_maximum_value
+            matches_for_range?
           elsif @array
-            if allows_all_values_in_array? && allows_blank_value? && allows_nil_value? && disallows_value_outside_of_array?
+            if matches_for_array?
               true
             else
               @failure_message = "#{@array} doesn't match array in validation"
@@ -117,6 +110,20 @@ EOT
 
         private
 
+        def matches_for_range?
+          disallows_lower_value &&
+            allows_minimum_value &&
+            disallows_higher_value &&
+            allows_maximum_value
+        end
+
+        def matches_for_array?
+          allows_all_values_in_array? &&
+            allows_blank_value? &&
+            allows_nil_value? &&
+            disallows_value_outside_of_array?
+        end
+
         def allows_blank_value?
           if @options.key?(:allow_blank)
             blank_values = ['', ' ', "\n", "\r", "\t", "\f"]
@@ -161,7 +168,7 @@ EOT
         end
 
         def disallows_value_outside_of_array?
-          if attribute_column.type == :boolean
+          if attribute_type == :boolean
             case @array
             when [true, false]
               Shoulda::Matchers.warn BOOLEAN_ALLOWS_BOOLEAN_MESSAGE
@@ -171,7 +178,7 @@ EOT
                 Shoulda::Matchers.warn BOOLEAN_ALLOWS_NIL_MESSAGE
                 return true
               else
-                raise NonNullableBooleanError, BOOLEAN_ALLOWS_NIL_WITH_NOT_NULL_MESSAGE
+                raise NonNullableBooleanError.create(@attribute)
               end
             end
           end
@@ -188,10 +195,10 @@ EOT
         end
 
         def outside_values
-          case attribute_column.type
+          case attribute_type
           when :boolean
             boolean_outside_values
-          when :integer, :float
+          when :fixnum
             [ARBITRARY_OUTSIDE_FIXNUM]
           when :decimal
             [ARBITRARY_OUTSIDE_DECIMAL]
@@ -209,15 +216,50 @@ EOT
             else              raise CouldNotDetermineValueOutsideOfArray
           end
 
-          if attribute_column.null
+          if attribute_allows_nil?
             values << nil
           end
 
           values
         end
 
+        def attribute_type
+          if attribute_column
+            column_type_to_attribute_type(attribute_column.type)
+          else
+            value_to_attribute_type(@subject.__send__(@attribute))
+          end
+        end
+
+        def attribute_allows_nil?
+          if attribute_column
+            attribute_column.null
+          else
+            true
+          end
+        end
+
         def attribute_column
-          @subject.class.columns_hash[@attribute.to_s]
+          if @subject.class.respond_to?(:columns_hash)
+            @subject.class.columns_hash[@attribute.to_s]
+          end
+        end
+
+        def column_type_to_attribute_type(type)
+          case type
+            when :boolean, :decimal then type
+            when :integer, :float then :fixnum
+            else :default
+          end
+        end
+
+        def value_to_attribute_type(value)
+          case value
+            when true, false then :boolean
+            when BigDecimal then :decimal
+            when Fixnum then :fixnum
+            else :default
+          end
         end
       end
     end

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

@@ -3,17 +3,19 @@ module Shoulda # :nodoc:
     module ActiveModel # :nodoc:
       class CouldNotDetermineValueOutsideOfArray < RuntimeError; end
 
-      class NonNullableBooleanError < Shoulda::Matchers::Error; end
-
-      class CouldNotClearAttribute < Shoulda::Matchers::Error
-        def self.create(actual_value)
-          super(actual_value: actual_value)
+      class NonNullableBooleanError < Shoulda::Matchers::Error
+        def self.create(attribute)
+          super(attribute: attribute)
         end
 
-        attr_accessor :actual_value
+        attr_accessor :attribute
 
         def message
-          "Expected value to be nil, but was #{actual_value.inspect}."
+          <<-EOT.strip
+You have specified that your model's #{attribute} should ensure inclusion of nil.
+However, #{attribute} is a boolean column which does not allow null values.
+Hence, this test will fail and there is no way to make it pass.
+          EOT
         end
       end
 

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

@@ -7,6 +7,9 @@ module Shoulda # :nodoc:
         #                 is_greater_than(6).
         #                 less_than(20)...(and so on) }
         class ComparisonMatcher < ValidationMatcher
+          DIFF_TO_COMPARE_PRECISION_CHANGE_NUMBER = 2**34
+          attr_reader :diff_to_compare
+
           def initialize(numericality_matcher, value, operator)
             unless numericality_matcher.respond_to? :diff_to_compare
               raise ArgumentError, 'numericality_matcher is invalid'
@@ -15,6 +18,7 @@ module Shoulda # :nodoc:
             @value = value
             @operator = operator
             @message = nil
+            @diff_to_compare = value.abs < DIFF_TO_COMPARE_PRECISION_CHANGE_NUMBER ? 0.000_001 : 1
           end
 
           def for(attribute)

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

@@ -28,12 +28,11 @@ module Shoulda # :nodoc:
         def matches?(subject)
           super(subject)
           @expected_message ||= :blank
-          disallows_value_of(blank_value, @expected_message)
-        rescue Shoulda::Matchers::ActiveModel::CouldNotClearAttribute => error
-          if @attribute == :password
-            raise Shoulda::Matchers::ActiveModel::CouldNotSetPasswordError.create(subject.class)
+
+          if secure_password_being_validated?
+            disallows_and_double_checks_value_of!(blank_value, @expected_message)
           else
-            raise error
+            disallows_value_of(blank_value, @expected_message)
           end
         end
 
@@ -43,6 +42,26 @@ module Shoulda # :nodoc:
 
         private
 
+        def secure_password_being_validated?
+          defined?(::ActiveModel::SecurePassword) &&
+            @subject.class.ancestors.include?(::ActiveModel::SecurePassword::InstanceMethodsOnActivation) &&
+            @attribute == :password
+        end
+
+        def disallows_and_double_checks_value_of!(value, message)
+          error_class = Shoulda::Matchers::ActiveModel::CouldNotSetPasswordError
+
+          disallows_value_of(value, message) do |matcher|
+            matcher._after_setting_value do
+              actual_value = @subject.__send__(@attribute)
+
+              if !actual_value.nil?
+                raise error_class.create(@subject.class)
+              end
+            end
+          end
+        end
+
         def blank_value
           if collection?
             []

data/lib/shoulda/matchers/doublespeak.rb

@@ -0,0 +1,27 @@
+require 'forwardable'
+
+module Shoulda
+  module Matchers
+    module Doublespeak
+      class << self
+        extend Forwardable
+
+        def_delegators :world, :register_double_collection,
+          :with_doubles_activated
+
+        def world
+          @_world ||= World.new
+        end
+      end
+    end
+  end
+end
+
+require 'shoulda/matchers/doublespeak/double'
+require 'shoulda/matchers/doublespeak/double_collection'
+require 'shoulda/matchers/doublespeak/double_implementation_registry'
+require 'shoulda/matchers/doublespeak/object_double'
+require 'shoulda/matchers/doublespeak/proxy_implementation'
+require 'shoulda/matchers/doublespeak/structs'
+require 'shoulda/matchers/doublespeak/stub_implementation'
+require 'shoulda/matchers/doublespeak/world'

data/lib/shoulda/matchers/doublespeak/double.rb

@@ -0,0 +1,74 @@
+module Shoulda
+  module Matchers
+    module Doublespeak
+      class Double
+        attr_reader :calls
+
+        def initialize(klass, method_name, implementation)
+          @klass = klass
+          @method_name = method_name
+          @implementation = implementation
+          @activated = false
+          @calls = []
+        end
+
+        def to_return(value = nil, &block)
+          if block
+            implementation.returns(&block)
+          else
+            implementation.returns(value)
+          end
+        end
+
+        def activate
+          unless @activated
+            store_original_method
+            replace_method_with_double
+            @activated = true
+          end
+        end
+
+        def deactivate
+          if @activated
+            restore_original_method
+            @activated = false
+          end
+        end
+
+        def record_call(args, block)
+          calls << MethodCall.new(args, block)
+        end
+
+        def call_original_method(object, args, block)
+          if original_method
+            original_method.bind(object).call(*args, &block)
+          end
+        end
+
+        private
+
+        attr_reader :klass, :method_name, :implementation, :original_method
+
+        def store_original_method
+          @original_method = klass.instance_method(method_name)
+        end
+
+        def replace_method_with_double
+          implementation = @implementation
+          double = self
+
+          klass.__send__(:define_method, method_name) do |*args, &block|
+            implementation.call(double, self, args, block)
+          end
+        end
+
+        def restore_original_method
+          original_method = @original_method
+          klass.__send__(:define_method, method_name) do |*args, &block|
+            original_method.bind(self).call(*args, &block)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/shoulda/matchers/doublespeak/double_collection.rb

@@ -0,0 +1,54 @@
+module Shoulda
+  module Matchers
+    module Doublespeak
+      class DoubleCollection
+        def initialize(klass)
+          @klass = klass
+          @doubles_by_method_name = {}
+        end
+
+        def register_stub(method_name)
+          register_double(method_name, :stub)
+        end
+
+        def register_proxy(method_name)
+          register_double(method_name, :proxy)
+        end
+
+        def activate
+          doubles_by_method_name.each do |method_name, double|
+            double.activate
+          end
+        end
+
+        def deactivate
+          doubles_by_method_name.each do |method_name, double|
+            double.deactivate
+          end
+        end
+
+        def calls_to(method_name)
+          double = doubles_by_method_name[method_name]
+
+          if double
+            double.calls
+          else
+            []
+          end
+        end
+
+        private
+
+        attr_reader :klass, :doubles_by_method_name
+
+        def register_double(method_name, implementation_type)
+          implementation =
+            DoubleImplementationRegistry.find(implementation_type)
+          double = Double.new(klass, method_name, implementation)
+          doubles_by_method_name[method_name] = double
+          double
+        end
+      end
+    end
+  end
+end

data/lib/shoulda/matchers/doublespeak/double_implementation_registry.rb

@@ -0,0 +1,27 @@
+module Shoulda
+  module Matchers
+    module Doublespeak
+      module DoubleImplementationRegistry
+        class << self
+          REGISTRY = {}
+
+          def find(type)
+            find_class!(type).create
+          end
+
+          def register(klass, type)
+            REGISTRY[type] = klass
+          end
+
+          private
+
+          def find_class!(type)
+            REGISTRY.fetch(type) do
+              raise ArgumentError, "No double implementation class found for '#{type}'"
+            end
+          end
+        end
+      end
+    end
+  end
+end