shoulda-matchers 3.1.3 → 4.0.0.rc1

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

@@ -14,7 +14,11 @@ module Shoulda
           @calls_by_method_name[method_name] || []
         end
 
-        def respond_to?(name, include_private = nil)
+        def respond_to?(_name, _include_private = nil)
+          true
+        end
+
+        def respond_to_missing?(_name, _include_all)
           true
         end
 

data/lib/shoulda/matchers/independent/delegate_method_matcher.rb

@@ -148,6 +148,26 @@ module Shoulda
       #         with_arguments(expedited: true)
       #     end
       #
+      # ##### allow_nil
+      #
+      # Use `allow_nil` if the delegation accounts for the fact that your
+      # delegate object could be nil. (This is mostly intended as an analogue to
+      # the `allow_nil` option that Rails' `delegate` helper takes.)
+      #
+      #     class Account
+      #       delegate :plan, to: :subscription, allow_nil: true
+      #     end
+      #
+      #     # RSpec
+      #     describe Account do
+      #       it { should delegate_method(:plan).to(:subscription).allow_nil }
+      #     end
+      #
+      #     # Minitest
+      #     class PageTest < Minitest::Test
+      #       should delegate_method(:plan).to(:subscription).allow_nil
+      #     end
+      #
       # @return [DelegateMethodMatcher]
       #
       def delegate_method(delegating_method)
@@ -162,10 +182,11 @@ module Shoulda
           @delegate_method = @delegating_method
           @delegate_object = Doublespeak::ObjectDouble.new
 
-          @delegated_arguments = []
-          @delegate_object_reader_method = nil
+          @context = nil
           @subject = nil
-          @subject_double_collection = nil
+          @delegate_object_reader_method = nil
+          @delegated_arguments = []
+          @expects_to_allow_nil_delegate_object = false
         end
 
         def in_context(context)
@@ -180,11 +201,13 @@ module Shoulda
 
           subject_has_delegating_method? &&
             subject_has_delegate_object_reader_method? &&
-            subject_delegates_to_delegate_object_correctly?
+            subject_delegates_to_delegate_object_correctly? &&
+            subject_handles_nil_delegate_object?
         end
 
         def description
-          string = "delegate #{formatted_delegating_method_name} to " +
+          string =
+            "delegate #{formatted_delegating_method_name} to the " +
             "#{formatted_delegate_object_reader_method_name} object"
 
           if delegated_arguments.any?
@@ -195,6 +218,12 @@ module Shoulda
             string << " as #{formatted_delegate_method}"
           end
 
+          if expects_to_allow_nil_delegate_object?
+            string << ", allowing "
+            string << formatted_delegate_object_reader_method_name
+            string << " to return nil"
+          end
+
           string
         end
 
@@ -220,6 +249,11 @@ module Shoulda
           self
         end
 
+        def allow_nil
+          @expects_to_allow_nil_delegate_object = true
+          self
+        end
+
         def build_delegating_method_prefix(prefix)
           case prefix
             when true, nil then delegate_object_reader_method
@@ -228,14 +262,29 @@ module Shoulda
         end
 
         def failure_message
-          "Expected #{class_under_test} to #{description}\n" +
-            "Method calls sent to " +
-            "#{formatted_delegate_object_reader_method_name(include_module: true)}:" +
-            formatted_calls_on_delegate_object
+          message = "Expected #{class_under_test} to #{description}.\n\n"
+
+          if failed_to_allow_nil_delegate_object?
+            message << formatted_delegating_method_name(include_module: true)
+            message << ' did delegate to '
+            message << formatted_delegate_object_reader_method_name
+            message << ' when it was non-nil, but it failed to account '
+            message << 'for when '
+            message << formatted_delegate_object_reader_method_name
+            message << ' *was* nil.'
+          else
+            message << 'Method calls sent to '
+            message << formatted_delegate_object_reader_method_name(
+              include_module: true,
+            )
+            message << ": #{formatted_calls_on_delegate_object}"
+          end
+
+          Shoulda::Matchers.word_wrap(message)
         end
 
         def failure_message_when_negated
-          "Expected #{class_under_test} not to #{description}, but it did"
+          "Expected #{class_under_test} not to #{description}, but it did."
         end
 
         protected
@@ -246,7 +295,6 @@ module Shoulda
           :delegating_method,
           :method,
           :delegate_method,
-          :subject_double_collection,
           :delegate_object,
           :delegate_object_reader_method
 
@@ -270,6 +318,10 @@ module Shoulda
           end
         end
 
+        def expects_to_allow_nil_delegate_object?
+          @expects_to_allow_nil_delegate_object
+        end
+
         def formatted_delegate_method(options = {})
           formatted_method_name_for(delegate_method, options)
         end
@@ -329,11 +381,7 @@ module Shoulda
         end
 
         def subject_delegates_to_delegate_object_correctly?
-          register_subject_double_collection
-
-          Doublespeak.with_doubles_activated do
-            subject.public_send(delegating_method, *delegated_arguments)
-          end
+          call_delegating_method_with_delegate_method_returning(delegate_object)
 
           if delegated_arguments.any?
             delegate_object_received_call_with_delegated_arguments?
@@ -342,13 +390,44 @@ module Shoulda
           end
         end
 
-        def register_subject_double_collection
+        def subject_handles_nil_delegate_object?
+          @subject_handled_nil_delegate_object =
+            if expects_to_allow_nil_delegate_object?
+              begin
+                call_delegating_method_with_delegate_method_returning(nil)
+                true
+              rescue Module::DelegationError
+                false
+              rescue NoMethodError => error
+                if error.message =~ /undefined method `#{delegate_method}' for nil:NilClass/
+                  false
+                else
+                  raise error
+                end
+              end
+            else
+              true
+            end
+        end
+
+        def failed_to_allow_nil_delegate_object?
+          expects_to_allow_nil_delegate_object? &&
+            !@subject_handled_nil_delegate_object
+        end
+
+        def call_delegating_method_with_delegate_method_returning(value)
+          register_subject_double_collection_to(value)
+
+          Doublespeak.with_doubles_activated do
+            subject.public_send(delegating_method, *delegated_arguments)
+          end
+        end
+
+        def register_subject_double_collection_to(returned_value)
           double_collection =
             Doublespeak.double_collection_for(subject.singleton_class)
           double_collection.register_stub(delegate_object_reader_method).
-            to_return(delegate_object)
-
-          @subject_double_collection = double_collection
+            to_return(returned_value)
         end
 
         def calls_to_delegate_method
@@ -363,7 +442,7 @@ module Shoulda
           string = ""
 
           if calls_on_delegate_object.any?
-            string << "\n"
+            string << "\n\n"
             calls_on_delegate_object.each_with_index do |call, i|
               name = call.method_name
               args = call.args.map { |arg| arg.inspect }.join(', ')

data/lib/shoulda/matchers/rails_shim.rb

@@ -1,70 +1,151 @@
 module Shoulda
   module Matchers
     # @private
-    class RailsShim
-      def self.verb_for_update
-        if action_pack_gte_4_1?
-          :patch
-        else
-          :put
+    module RailsShim
+      class << self
+        def action_pack_gte_4_1?
+          Gem::Requirement.new('>= 4.1').satisfied_by?(action_pack_version)
         end
-      end
 
-      def self.type_cast_default_for(model, column)
-        if model.respond_to?(:column_defaults)
-          # Rails 4.2
-          model.column_defaults[column.name]
-        else
-          column.default
+        def action_pack_gte_5?
+          Gem::Requirement.new('>= 5').satisfied_by?(action_pack_version)
+        end
+
+        def action_pack_lt_5?
+          Gem::Requirement.new('< 5').satisfied_by?(action_pack_version)
+        end
+
+        def action_pack_version
+          Gem::Version.new(::ActionPack::VERSION::STRING)
+        rescue NameError
+          Gem::Version.new('0')
+        end
+
+        def active_record_gte_5?
+          Gem::Requirement.new('>= 5').satisfied_by?(active_record_version)
         end
-      end
 
-      def self.serialized_attributes_for(model)
-        if defined?(::ActiveRecord::Type::Serialized)
-          # Rails 5+
-          model.columns.select do |column|
-            column.cast_type.is_a?(::ActiveRecord::Type::Serialized)
-          end.inject({}) do |hash, column|
-            hash[column.name.to_s] = column.cast_type.coder
-            hash
+        def active_record_version
+          Gem::Version.new(::ActiveRecord::VERSION::STRING)
+        rescue NameError
+          Gem::Version.new('0')
+        end
+
+        def generate_validation_message(
+          record,
+          attribute,
+          type,
+          model_name,
+          options
+        )
+          if record && record.errors.respond_to?(:generate_message)
+            record.errors.generate_message(attribute.to_sym, type, options)
+          else
+            simply_generate_validation_message(
+              attribute,
+              type,
+              model_name,
+              options,
+            )
           end
-        else
-          model.serialized_attributes
+        rescue RangeError
+          simply_generate_validation_message(
+            attribute,
+            type,
+            model_name,
+            options,
+          )
         end
-      end
 
-      def self.generate_validation_message(record, attribute, type, model_name, options)
-        if record && record.errors.respond_to?(:generate_message)
-          record.errors.generate_message(attribute.to_sym, type, options)
-        else
-          simply_generate_validation_message(attribute, type, model_name, options)
+        def make_controller_request(context, verb, action, request_params)
+          params =
+            if action_pack_gte_5?
+              { params: request_params }
+            else
+              request_params
+            end
+
+          context.__send__(verb, action, params)
         end
-      rescue RangeError
-        simply_generate_validation_message(attribute, type, model_name, options)
-      end
 
-      def self.simply_generate_validation_message(attribute, type, model_name, options)
-        default_translation_keys = [
-          :"activerecord.errors.models.#{model_name}.#{type}",
-          :"activerecord.errors.messages.#{type}",
-          :"errors.attributes.#{attribute}.#{type}",
-          :"errors.messages.#{type}"
-        ]
-        primary_translation_key = :"activerecord.errors.models.#{model_name}.attributes.#{attribute}.#{type}"
-        translate_options = { default: default_translation_keys }.merge(options)
-        I18n.translate(primary_translation_key, translate_options)
-      end
+        def serialized_attributes_for(model)
+          if defined?(::ActiveRecord::Type::Serialized)
+            # Rails 5+
+            serialized_columns = model.columns.select do |column|
+              model.type_for_attribute(column.name).is_a?(
+                ::ActiveRecord::Type::Serialized,
+              )
+            end
 
-      def self.active_record_major_version
-        ::ActiveRecord::VERSION::MAJOR
-      end
+            serialized_columns.inject({}) do |hash, column|
+              hash[column.name.to_s] = model.type_for_attribute(column.name).coder
+              hash
+            end
+          else
+            model.serialized_attributes
+          end
+        end
 
-      def self.action_pack_gte_4_1?
-        Gem::Requirement.new('>= 4.1').satisfied_by?(action_pack_version)
-      end
+        def type_cast_default_for(model, column)
+          if model.respond_to?(:column_defaults)
+            # Rails 4.2
+            model.column_defaults[column.name]
+          else
+            column.default
+          end
+        end
 
-      def self.action_pack_version
-        Gem::Version.new(::ActionPack::VERSION::STRING)
+        def tables_and_views(connection)
+          if active_record_gte_5?
+            connection.data_sources
+          else
+            connection.tables
+          end
+        end
+
+        def verb_for_update
+          if action_pack_gte_4_1?
+            :patch
+          else
+            :put
+          end
+        end
+
+        def validation_message_key_for_association_required_option
+          if active_record_gte_5?
+            :required
+          else
+            :blank
+          end
+        end
+
+        private
+
+        def simply_generate_validation_message(
+          attribute,
+          type,
+          model_name,
+          options
+        )
+          default_translation_keys = [
+            :"activerecord.errors.models.#{model_name}.#{type}",
+            :"activerecord.errors.messages.#{type}",
+            :"errors.attributes.#{attribute}.#{type}",
+            :"errors.messages.#{type}",
+          ]
+          primary_translation_key = [
+            :activerecord,
+            :errors,
+            :models,
+            model_name,
+            :attributes,
+            attribute,
+            type,
+          ]
+          translate_options =
+            { default: default_translation_keys }.merge(options)
+          I18n.translate(primary_translation_key, translate_options)
+        end
       end
     end
   end

data/lib/shoulda/matchers/routing.rb

@@ -2,8 +2,8 @@ module Shoulda
   module Matchers
     # @private
     module Routing
-      def route(method, path)
-        ActionController::RouteMatcher.new(method, path, self)
+      def route(method, path, port: nil)
+        ActionController::RouteMatcher.new(self, method, path, port: port)
       end
     end
   end

data/lib/shoulda/matchers/util.rb

@@ -27,6 +27,7 @@ module Shoulda
       end
 
       def self.indent(string, width)
+        return if !string
         indentation = ' ' * width
         string.split(/[\n\r]/).map { |line| indentation + line }.join("\n")
       end
@@ -40,7 +41,14 @@ module Shoulda
       end
 
       def self.inspect_value(value)
-        "‹#{value.inspect}›"
+        case value
+        when Hash
+          inspect_hash(value)
+        when Range
+          inspect_range(value)
+        else
+          "‹#{value.inspect}›"
+        end
       end
 
       def self.inspect_values(values)
@@ -51,6 +59,20 @@ module Shoulda
         "#{inspect_value(range.first)} to #{inspect_value(range.last)}"
       end
 
+      def self.inspect_hash(hash)
+        output = '‹{'
+
+        output << hash.map { |key, value|
+          if key.is_a?(Symbol)
+            "#{key}: #{value.inspect}"
+          else
+            "#{key.inspect} => #{value.inspect}"
+          end
+        }.join(', ')
+
+        output << '}›'
+      end
+
       def self.dummy_value_for(column_type, array: false)
         if array
           [dummy_value_for(column_type, array: false)]