rspec-mocks 3.0.4 → 3.12.6

data/lib/rspec/mocks/syntax.rb

@@ -10,7 +10,7 @@ module RSpec
       end
 
       # @private
-      def self.warn_unless_should_configured(method_name ,replacement = "the new `:expect` syntax or explicitly enable `:should`")
+      def self.warn_unless_should_configured(method_name , replacement="the new `:expect` syntax or explicitly enable `:should`")
         if @warn_about_should
           RSpec.deprecate(
             "Using `#{method_name}` from rspec-mocks' old `:should` syntax without explicitly enabling the syntax",
@@ -23,7 +23,7 @@ module RSpec
 
       # @api private
       # Enables the should syntax (`dbl.stub`, `dbl.should_receive`, etc).
-      def self.enable_should(syntax_host = default_should_syntax_host)
+      def self.enable_should(syntax_host=default_should_syntax_host)
         @warn_about_should = false if syntax_host == default_should_syntax_host
         return if should_enabled?(syntax_host)
 
@@ -41,14 +41,14 @@ module RSpec
           def stub(message_or_hash, opts={}, &block)
             ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
             if ::Hash === message_or_hash
-              message_or_hash.each {|message, value| stub(message).and_return value }
+              message_or_hash.each { |message, value| stub(message).and_return value }
             else
               ::RSpec::Mocks.allow_message(self, message_or_hash, opts, &block)
             end
           end
 
           def unstub(message)
-            ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__, "`allow(...).to_receive(...).and_call_original` or explicitly enable `:should`")
+            ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__, "`allow(...).to receive(...).and_call_original` or explicitly enable `:should`")
             ::RSpec::Mocks.space.proxy_for(self).remove_stub(message)
           end
 
@@ -86,7 +86,7 @@ module RSpec
 
       # @api private
       # Disables the should syntax (`dbl.stub`, `dbl.should_receive`, etc).
-      def self.disable_should(syntax_host = default_should_syntax_host)
+      def self.disable_should(syntax_host=default_should_syntax_host)
         return unless should_enabled?(syntax_host)
 
         syntax_host.class_exec do
@@ -107,7 +107,7 @@ module RSpec
 
       # @api private
       # Enables the expect syntax (`expect(dbl).to receive`, `allow(dbl).to receive`, etc).
-      def self.enable_expect(syntax_host = ::RSpec::Mocks::ExampleMethods)
+      def self.enable_expect(syntax_host=::RSpec::Mocks::ExampleMethods)
         return if expect_enabled?(syntax_host)
 
         syntax_host.class_exec do
@@ -147,7 +147,7 @@ module RSpec
 
       # @api private
       # Disables the expect syntax (`expect(dbl).to receive`, `allow(dbl).to receive`, etc).
-      def self.disable_expect(syntax_host = ::RSpec::Mocks::ExampleMethods)
+      def self.disable_expect(syntax_host=::RSpec::Mocks::ExampleMethods)
         return unless expect_enabled?(syntax_host)
 
         syntax_host.class_exec do
@@ -166,13 +166,13 @@ module RSpec
 
       # @api private
       # Indicates whether or not the should syntax is enabled.
-      def self.should_enabled?(syntax_host = default_should_syntax_host)
+      def self.should_enabled?(syntax_host=default_should_syntax_host)
         syntax_host.method_defined?(:should_receive)
       end
 
       # @api private
       # Indicates whether or not the expect syntax is enabled.
-      def self.expect_enabled?(syntax_host = ::RSpec::Mocks::ExampleMethods)
+      def self.expect_enabled?(syntax_host=::RSpec::Mocks::ExampleMethods)
         syntax_host.method_defined?(:allow)
       end
 
@@ -214,11 +214,10 @@ if defined?(BasicObject)
     # the end of the example.
     #
     # @example
-    #
-    #     logger = double('logger')
-    #     thing_that_logs = ThingThatLogs.new(logger)
-    #     logger.should_receive(:log)
-    #     thing_that_logs.do_something_that_logs_a_message
+    #   logger = double('logger')
+    #   thing_that_logs = ThingThatLogs.new(logger)
+    #   logger.should_receive(:log)
+    #   thing_that_logs.do_something_that_logs_a_message
     #
     # @note This is only available when you have enabled the `should` syntax.
     # @see RSpec::Mocks::ExampleMethods#expect
@@ -232,10 +231,9 @@ if defined?(BasicObject)
     # Tells the object to respond to the message with the specified value.
     #
     # @example
-    #
-    #     counter.stub(:count).and_return(37)
-    #     counter.stub(:count => 37)
-    #     counter.stub(:count) { 37 }
+    #   counter.stub(:count).and_return(37)
+    #   counter.stub(:count => 37)
+    #   counter.stub(:count) { 37 }
     #
     # @note This is only available when you have enabled the `should` syntax.
     # @see RSpec::Mocks::ExampleMethods#allow
@@ -269,10 +267,9 @@ if defined?(BasicObject)
     # implementation calls `foo.baz.bar`, the stub will not work.
     #
     # @example
-    #
-    #     double.stub_chain("foo.bar") { :baz }
-    #     double.stub_chain(:foo, :bar => :baz)
-    #     double.stub_chain(:foo, :bar) { :baz }
+    #   double.stub_chain("foo.bar") { :baz }
+    #   double.stub_chain(:foo, :bar => :baz)
+    #   double.stub_chain(:foo, :bar) { :baz }
     #
     #     # Given any of ^^ these three forms ^^:
     #     double.foo.bar # => :baz
@@ -311,15 +308,14 @@ class Class
   # class.
   #
   # @example
+  #   Car.any_instance.should_receive(:go)
+  #   race = Race.new
+  #   race.cars << Car.new
+  #   race.go # assuming this delegates to all of its cars
+  #           # this example would pass
   #
-  #     Car.any_instance.should_receive(:go)
-  #     race = Race.new
-  #     race.cars << Car.new
-  #     race.go # assuming this delegates to all of its cars
-  #             # this example would pass
-  #
-  #     Account.any_instance.stub(:balance) { Money.new(:USD, 25) }
-  #     Account.new.balance # => Money.new(:USD, 25))
+  #   Account.any_instance.stub(:balance) { Money.new(:USD, 25) }
+  #   Account.new.balance # => Money.new(:USD, 25))
   #
   # @return [Recorder]
   #

data/lib/rspec/mocks/targets.rb

@@ -1,12 +1,8 @@
 module RSpec
   module Mocks
     # @private
-    class TargetBase
-      def initialize(target)
-        @target = target
-      end
-
-      def self.delegate_to(matcher_method)
+    module TargetDelegationClassMethods
+      def delegate_to(matcher_method)
         define_method(:to) do |matcher, &block|
           unless matcher_allowed?(matcher)
             raise_unsupported_matcher(:to, matcher)
@@ -15,11 +11,11 @@ module RSpec
         end
       end
 
-      def self.delegate_not_to(matcher_method, options = {})
+      def delegate_not_to(matcher_method, options={})
         method_name = options.fetch(:from)
         define_method(method_name) do |matcher, &block|
           case matcher
-          when Matchers::Receive
+          when Matchers::Receive, Matchers::HaveReceived
             define_matcher(matcher, matcher_method, &block)
           when Matchers::ReceiveMessages, Matchers::ReceiveMessageChain
             raise_negation_unsupported(method_name, matcher)
@@ -29,58 +25,86 @@ module RSpec
         end
       end
 
-      def self.disallow_negation(method_name)
-        define_method(method_name) do |matcher, *args|
+      def disallow_negation(method_name)
+        define_method(method_name) do |matcher, *_args|
           raise_negation_unsupported(method_name, matcher)
         end
       end
+    end
+
+    # @private
+    module TargetDelegationInstanceMethods
+      attr_reader :target
 
     private
 
       def matcher_allowed?(matcher)
-        matcher.class.name.start_with?("RSpec::Mocks::Matchers".freeze)
+        Matchers::Matcher === matcher
       end
 
       def define_matcher(matcher, name, &block)
-        matcher.__send__(name, @target, &block)
+        matcher.__send__(name, target, &block)
       end
 
       def raise_unsupported_matcher(method_name, matcher)
         raise UnsupportedMatcherError,
-          "only the `receive` or `receive_messages` matchers are supported " +
-          "with `#{expression}(...).#{method_name}`, but you have provided: #{matcher}"
+              "only the `receive`, `have_received` and `receive_messages` matchers are supported " \
+              "with `#{expression}(...).#{method_name}`, but you have provided: #{matcher}"
       end
 
       def raise_negation_unsupported(method_name, matcher)
         raise NegationUnsupportedError,
-          "`#{expression}(...).#{method_name} #{matcher.name}` is not supported since it " +
-          "doesn't really make sense. What would it even mean?"
+              "`#{expression}(...).#{method_name} #{matcher.matcher_name}` is not supported since it " \
+              "doesn't really make sense. What would it even mean?"
+      end
+    end
+
+    # @private
+    class TargetBase
+      def initialize(target)
+        @target = target
       end
 
+      extend TargetDelegationClassMethods
+      include TargetDelegationInstanceMethods
+    end
+
+    # @private
+    module ExpectationTargetMethods
+      extend TargetDelegationClassMethods
+      include TargetDelegationInstanceMethods
+
+      delegate_to :setup_expectation
+      delegate_not_to :setup_negative_expectation, :from => :not_to
+      delegate_not_to :setup_negative_expectation, :from => :to_not
+
       def expression
-        self.class::EXPRESSION
+        :expect
       end
     end
 
+    # @private
+    class ExpectationTarget < TargetBase
+      include ExpectationTargetMethods
+    end
+
     # @private
     class AllowanceTarget < TargetBase
-      EXPRESSION = :allow
+      def expression
+        :allow
+      end
+
       delegate_to :setup_allowance
       disallow_negation :not_to
       disallow_negation :to_not
     end
 
-    # @private
-    class ExpectationTarget < TargetBase
-      EXPRESSION = :expect
-      delegate_to :setup_expectation
-      delegate_not_to :setup_negative_expectation, :from => :not_to
-      delegate_not_to :setup_negative_expectation, :from => :to_not
-    end
-
     # @private
     class AnyInstanceAllowanceTarget < TargetBase
-      EXPRESSION = :allow_any_instance_of
+      def expression
+        :allow_any_instance_of
+      end
+
       delegate_to :setup_any_instance_allowance
       disallow_negation :not_to
       disallow_negation :to_not
@@ -88,7 +112,10 @@ module RSpec
 
     # @private
     class AnyInstanceExpectationTarget < TargetBase
-      EXPRESSION = :expect_any_instance_of
+      def expression
+        :expect_any_instance_of
+      end
+
       delegate_to :setup_any_instance_expectation
       delegate_not_to :setup_any_instance_negative_expectation, :from => :not_to
       delegate_not_to :setup_any_instance_negative_expectation, :from => :to_not

data/lib/rspec/mocks/test_double.rb

@@ -39,12 +39,12 @@ module RSpec
 
       # @private
       def inspect
-        "#<#{self.class}:#{sprintf '0x%x', self.object_id} @name=#{@name.inspect}>"
+        TestDoubleFormatter.format(self)
       end
 
       # @private
       def to_s
-        inspect.gsub('<','[').gsub('>',']')
+        inspect.tr('<', '[').tr('>', ']')
       end
 
       # @private
@@ -54,7 +54,7 @@ module RSpec
 
       # @private
       def __build_mock_proxy_unless_expired(order_group)
-        __raise_expired_error or __build_mock_proxy(order_group)
+        __raise_expired_error || __build_mock_proxy(order_group)
       end
 
       # @private
@@ -66,6 +66,7 @@ module RSpec
       # doubles.
       def freeze
         RSpec.warn_with("WARNING: you attempted to freeze a test double. This is explicitly a no-op as freezing doubles can lead to undesired behaviour when resetting tests.")
+        self
       end
 
     private
@@ -91,14 +92,14 @@ module RSpec
         # https://github.com/jruby/jruby/issues/1398
         visibility = proxy.visibility_for(message)
         if visibility == :private || visibility == :protected
-          ErrorGenerator.new(self, @name).raise_non_public_error(
+          ErrorGenerator.new(self).raise_non_public_error(
             message, visibility
           )
         end
 
         # Required wrapping doubles in an Array on Ruby 1.9.2
         raise NoMethodError if [:to_a, :to_ary].include? message
-        proxy.raise_unexpected_message_error(message, *args)
+        proxy.raise_unexpected_message_error(message, args)
       end
 
       def assign_stubs(stubs)
@@ -112,12 +113,12 @@ module RSpec
       end
 
       def __build_mock_proxy(order_group)
-        TestDoubleProxy.new(self, order_group, @name)
+        TestDoubleProxy.new(self, order_group)
       end
 
       def __raise_expired_error
         return false unless @__expired
-        ErrorGenerator.new(self, @name).raise_expired_test_double_error
+        ErrorGenerator.new(self).raise_expired_test_double_error
       end
 
       def initialize_copy(other)
@@ -131,5 +132,40 @@ module RSpec
     class Double
       include TestDouble
     end
+
+    # @private
+    module TestDoubleFormatter
+      def self.format(dbl, unwrap=false)
+        format = "#{type_desc(dbl)}#{verified_module_desc(dbl)} #{name_desc(dbl)}"
+        return format if unwrap
+        "#<#{format}>"
+      end
+
+      class << self
+      private
+
+        def type_desc(dbl)
+          case dbl
+          when InstanceVerifyingDouble then "InstanceDouble"
+          when ClassVerifyingDouble    then "ClassDouble"
+          when ObjectVerifyingDouble   then "ObjectDouble"
+          else "Double"
+          end
+        end
+
+        # @private
+        IVAR_GET = Object.instance_method(:instance_variable_get)
+
+        def verified_module_desc(dbl)
+          return nil unless VerifyingDouble === dbl
+          "(#{IVAR_GET.bind(dbl).call(:@doubled_module).description})"
+        end
+
+        def name_desc(dbl)
+          return "(anonymous)" unless (name = IVAR_GET.bind(dbl).call(:@name))
+          name.inspect
+        end
+      end
+    end
   end
 end

data/lib/rspec/mocks/verifying_double.rb

@@ -1,9 +1,7 @@
 RSpec::Support.require_rspec_mocks 'verifying_proxy'
-require 'stringio'
 
 module RSpec
   module Mocks
-
     # @private
     module VerifyingDouble
       def respond_to?(message, include_private=false)
@@ -11,11 +9,11 @@ module RSpec
 
         method_ref = __mock_proxy.method_reference[message]
 
-        return case method_ref.visibility
-          when :public    then true
-          when :private   then include_private
-          when :protected then include_private || RUBY_VERSION.to_f < 2.0
-          else !method_ref.unimplemented?
+        case method_ref.visibility
+        when :public    then true
+        when :private   then include_private
+        when :protected then include_private || RUBY_VERSION.to_f < 2.0
+        else !method_ref.unimplemented?
         end
       end
 
@@ -29,27 +27,38 @@ module RSpec
           else
             __mock_proxy.ensure_publicly_implemented(message, self)
           end
+
+          __mock_proxy.validate_arguments!(message, args)
         end
 
         super
       end
 
       # Redefining `__send__` causes ruby to issue a warning.
-      old, $stderr = $stderr, StringIO.new
+      old, $VERBOSE = $VERBOSE, nil
       def __send__(name, *args, &block)
         @__sending_message = name
         super
       ensure
         @__sending_message = nil
       end
-      $stderr = old
+      ruby2_keywords :__send__ if respond_to?(:ruby2_keywords, true)
+      $VERBOSE = old
 
       def send(name, *args, &block)
         __send__(name, *args, &block)
       end
+      ruby2_keywords :send if respond_to?(:ruby2_keywords, true)
 
-      def initialize(*args)
-        super
+      def initialize(doubled_module, *args)
+        @doubled_module = doubled_module
+
+        possible_name = args.first
+        name = if String === possible_name || Symbol === possible_name
+                 args.shift
+               end
+
+        super(name, *args)
         @__sending_message = nil
       end
     end
@@ -63,19 +72,10 @@ module RSpec
       include TestDouble
       include VerifyingDouble
 
-      def initialize(doubled_module, *args)
-        @doubled_module = doubled_module
-
-        super(
-          "#{doubled_module.description} (instance)",
-          *args
-        )
-      end
-
       def __build_mock_proxy(order_group)
-        VerifyingProxy.new(self, order_group, @name,
-          @doubled_module,
-          InstanceMethodReference
+        VerifyingProxy.new(self, order_group,
+                           @doubled_module,
+                           InstanceMethodReference
         )
       end
     end
@@ -88,22 +88,17 @@ module RSpec
       include TestDouble
       include VerifyingDouble
 
-      def as_stubbed_const(options = {})
+      def as_stubbed_const(options={})
         ConstantMutator.stub(@doubled_module.const_to_replace, self, options)
         self
       end
 
     private
 
-      def initialize(doubled_module, *args)
-        @doubled_module = doubled_module
-        super(doubled_module.description, *args)
-      end
-
       def __build_mock_proxy(order_group)
-        VerifyingProxy.new(self, order_group, @name,
-          @doubled_module,
-          ObjectMethodReference
+        VerifyingProxy.new(self, order_group,
+                           @doubled_module,
+                           ObjectMethodReference
         )
       end
     end
@@ -124,6 +119,5 @@ module RSpec
     class ClassVerifyingDouble < Module
       include ObjectVerifyingDoubleMethods
     end
-
   end
 end

data/lib/rspec/mocks/{verifying_message_expecation.rb → verifying_message_expectation.rb}

@@ -2,13 +2,11 @@ RSpec::Support.require_rspec_support 'method_signature_verifier'
 
 module RSpec
   module Mocks
-
     # A message expectation that knows about the real implementation of the
     # message being expected, so that it can verify that any expectations
     # have the valid arguments.
     # @api private
     class VerifyingMessageExpectation < MessageExpectation
-
       # A level of indirection is used here rather than just passing in the
       # method itself, since method look up is expensive and we only want to
       # do it if actually needed.
@@ -25,30 +23,27 @@ module RSpec
 
       # @private
       def with(*args, &block)
-        unless ArgumentMatchers::AnyArgsMatcher === args.first
-          expected_args = if ArgumentMatchers::NoArgsMatcher === args.first
-            []
-          elsif args.length > 0
-            args
-          else
-            # No arguments given, this will raise.
-            super
+        super(*args, &block).tap do
+          validate_expected_arguments! do |signature|
+            example_call_site_args = [:an_arg] * signature.min_non_kw_args
+            example_call_site_args << :kw_args_hash if signature.required_kw_args.any?
+            @argument_list_matcher.resolve_expected_args_based_on(example_call_site_args)
           end
-
-          validate_arguments!(expected_args)
         end
-        super
       end
+      ruby2_keywords(:with) if respond_to?(:ruby2_keywords, true)
 
     private
 
-      def validate_arguments!(actual_args)
+      def validate_expected_arguments!
         return if method_reference.nil?
 
         method_reference.with_signature do |signature|
-          verifier = Support::MethodSignatureVerifier.new(signature, actual_args)
+          args     = yield signature
+          verifier = Support::LooseSignatureVerifier.new(signature, args)
+
           unless verifier.valid?
-            # Fail fast is required, otherwise the message expecation will fail
+            # Fail fast is required, otherwise the message expectation will fail
             # as well ("expected method not called") and clobber this one.
             @failed_fast = true
             @error_generator.raise_invalid_arguments_error(verifier)