rspec-mocks 3.0.0.beta2 → 3.0.0.rc1

data/lib/rspec/mocks/any_instance.rb

@@ -0,0 +1,10 @@
+%w[
+  any_instance/chain
+  any_instance/stub_chain
+  any_instance/stub_chain_chain
+  any_instance/expect_chain_chain
+  any_instance/expectation_chain
+  any_instance/message_chains
+  any_instance/recorder
+  any_instance/proxy
+].each { |f| RSpec::Support.require_rspec_mocks(f) }

data/lib/rspec/mocks/any_instance/chain.rb

@@ -1,13 +1,20 @@
 module RSpec
   module Mocks
+    # @private
     module AnyInstance
+      # @private
       class Chain
         def initialize(recorder, *args, &block)
           @recorder          = recorder
           @expectation_args  = args
           @expectation_block = block
+          @argument_list_matcher = ArgumentListMatcher::MATCH_ALL
         end
 
+        # @private
+        #
+        # Provides convenience methods for recording customizations on message
+        # expectations.
         module Customizations
           # @macro [attach] record
           #   @method $1(*args, &block)
@@ -57,6 +64,11 @@ module RSpec
           end
         end
 
+        # @private
+        def matches_args?(*args)
+          @argument_list_matcher.args_match?(*args)
+        end
+
         # @private
         def expectation_fulfilled!
           @expectation_fulfilled = true
@@ -67,6 +79,11 @@ module RSpec
           super
         end
 
+        def with(*args, &block)
+          @argument_list_matcher = ArgumentListMatcher.new(*args)
+          super
+        end
+
         private
 
         def negated?

data/lib/rspec/mocks/any_instance/expect_chain_chain.rb

@@ -16,7 +16,7 @@ module RSpec
           super.tap { @expectation_fulfilled = true }
         end
 
-        private
+      private
 
         def create_message_expectation_on(instance)
           ::RSpec::Mocks::ExpectChain.expect_chain_on(instance, *@expectation_args, &@expectation_block)

data/lib/rspec/mocks/any_instance/expectation_chain.rb

@@ -1,7 +1,7 @@
 module RSpec
   module Mocks
     module AnyInstance
-      # @api private
+      # @private
       class ExpectationChain < Chain
         def expectation_fulfilled?
           @expectation_fulfilled || constrained_to_any_of?(:never, :any_number_of_times)
@@ -12,20 +12,23 @@ module RSpec
           super
         end
 
-        private
+      private
+
         def verify_invocation_order(rspec_method_name, *args, &block)
         end
       end
 
-      # @api private
+      # @private
       class PositiveExpectationChain < ExpectationChain
 
-        private
+      private
 
         def create_message_expectation_on(instance)
           proxy = ::RSpec::Mocks.space.proxy_for(instance)
-          expected_from = IGNORED_BACKTRACE_LINE
-          me = proxy.add_message_expectation(expected_from, *@expectation_args, &@expectation_block)
+          method_name, opts = @expectation_args
+          opts = (opts || {}).merge(:expected_form => IGNORED_BACKTRACE_LINE)
+
+          me = proxy.add_message_expectation(method_name, opts, &@expectation_block)
           if RSpec::Mocks.configuration.yield_receiver_to_any_instance_implementation_blocks?
             me.and_yield_receiver_to_implementation
           end

data/lib/rspec/mocks/any_instance/message_chains.rb

@@ -32,6 +32,15 @@ module RSpec
           end
         end
 
+        # @private
+        def each_unfulfilled_expectation_matching(method_name, *args)
+          @chains_by_method_name[method_name].each do |chain|
+            if !chain.expectation_fulfilled? && chain.matches_args?(*args)
+              yield chain
+            end
+          end
+        end
+
         # @private
         def all_expectations_fulfilled?
           @chains_by_method_name.all? do |method_name, chains|
@@ -61,7 +70,7 @@ module RSpec
           end
         end
 
-        private
+      private
 
         def raise_if_second_instance_to_receive_message(instance)
           @instance_with_expectation ||= instance if ExpectationChain === instance

data/lib/rspec/mocks/any_instance/proxy.rb

@@ -0,0 +1,112 @@
+module RSpec
+  module Mocks
+    module AnyInstance
+      # @private
+      # The `AnyInstance::Recorder` is responsible for redefining the klass's
+      # instance method in order to add any stubs/expectations the first time
+      # the method is called. It's not capable of updating a stub on an instance
+      # that's already been previously stubbed (either directly, or via
+      # `any_instance`).
+      #
+      # This proxy sits in front of the recorder and delegates both to it
+      # and to the `RSpec::Mocks::Proxy` for each already mocked or stubbed
+      # instance of the class, in order to propogates changes to the instances.
+      #
+      # Note that unlike `RSpec::Mocks::Proxy`, this proxy class is stateless
+      # and is not persisted in `RSpec::Mocks.space`.
+      #
+      # Proxying for the message expectation fluent interface (typically chained
+      # off of the return value of one of these methods) is provided by the
+      # `FluentInterfaceProxy` class below.
+      class Proxy
+        def initialize(recorder, target_proxies)
+          @recorder       = recorder
+          @target_proxies = target_proxies
+        end
+
+        def klass
+          @recorder.klass
+        end
+
+        def stub(method_name_or_method_map, &block)
+          if Hash === method_name_or_method_map
+            method_name_or_method_map.each do |method_name, return_value|
+              stub(method_name).and_return(return_value)
+            end
+          else
+            perform_proxying(__method__, [method_name_or_method_map], block) do |proxy|
+              proxy.add_stub(method_name_or_method_map, &block)
+            end
+          end
+        end
+
+        def unstub(method_name)
+          perform_proxying(__method__, [method_name], nil) do |proxy|
+            proxy.remove_stub_if_present(method_name)
+          end
+        end
+
+        def stub_chain(*chain, &block)
+          perform_proxying(__method__, chain, block) do |proxy|
+            Mocks::StubChain.stub_chain_on(proxy.object, *chain, &block)
+          end
+        end
+
+        def expect_chain(*chain, &block)
+          perform_proxying(__method__, chain, block) do |proxy|
+            Mocks::ExpectChain.expect_chain_on(proxy.object, *chain, &block)
+          end
+        end
+
+        def should_receive(method_name, &block)
+          perform_proxying(__method__, [method_name], block) do |proxy|
+            proxy.add_message_expectation(method_name, &block)
+          end
+        end
+
+        def should_not_receive(method_name, &block)
+          perform_proxying(__method__, [method_name], block) do |proxy|
+            proxy.add_message_expectation(method_name, &block).never
+          end
+        end
+
+      private
+
+        def perform_proxying(method_name, args, block, &target_proxy_block)
+          recorder_value = @recorder.__send__(method_name, *args, &block)
+          proxy_values   = @target_proxies.map(&target_proxy_block)
+          FluentInterfaceProxy.new([recorder_value] + proxy_values)
+        end
+      end
+
+      # @private
+      # Delegates messages to each of the given targets in order to
+      # provide the fluent interface that is available off of message
+      # expectations when dealing with `any_instance`.
+      #
+      # `targets` will typically contain 1 of the `AnyInstance::Recorder`
+      # return values and N `MessageExpectation` instances (one per instance
+      # of the `any_instance` klass).
+      class FluentInterfaceProxy
+        def initialize(targets)
+          @targets = targets
+        end
+
+        if RUBY_VERSION.to_f > 1.8
+          def respond_to_missing?(method_name, include_private = false)
+            super || @targets.first.respond_to?(method_name, include_private)
+          end
+        else
+          def respond_to?(method_name, include_private = false)
+            super || @targets.first.respond_to?(method_name, include_private)
+          end
+        end
+
+        def method_missing(*args, &block)
+          return_values = @targets.map { |t| t.__send__(*args, &block) }
+          FluentInterfaceProxy.new(return_values)
+        end
+      end
+    end
+  end
+end

data/lib/rspec/mocks/any_instance/recorder.rb

@@ -26,15 +26,9 @@ module RSpec
         # instance of this object that invokes the submitted method.
         #
         # @see Methods#stub
-        def stub(method_name_or_method_map, &block)
-          if Hash === method_name_or_method_map
-            method_name_or_method_map.each do |method_name, return_value|
-              stub(method_name).and_return(return_value)
-            end
-          else
-            observe!(method_name_or_method_map)
-            message_chains.add(method_name_or_method_map, StubChain.new(self, method_name_or_method_map, &block))
-          end
+        def stub(method_name, &block)
+          observe!(method_name)
+          message_chains.add(method_name, StubChain.new(self, method_name, &block))
         end
 
         # Initializes the recording a stub chain to be played back against any
@@ -49,7 +43,7 @@ module RSpec
           end
         end
 
-        # @api private
+        # @private
         def expect_chain(*method_names_and_optional_return_values, &block)
           @expectation_set = true
           normalize_chain(*method_names_and_optional_return_values) do |method_name, args|
@@ -69,6 +63,9 @@ module RSpec
           message_chains.add(method_name, PositiveExpectationChain.new(self, method_name, &block))
         end
 
+        # The opposite of `should_receive`
+        #
+        # @see Methods#should_not_receive
         def should_not_receive(method_name, &block)
           should_receive(method_name, &block).never
         end
@@ -82,9 +79,6 @@ module RSpec
             raise RSpec::Mocks::MockExpectationError, "The method `#{method_name}` was not stubbed or was already unstubbed"
           end
           message_chains.remove_stub_chains_for!(method_name)
-          ::RSpec::Mocks.space.proxies_of(@klass).each do |proxy|
-            stubs[method_name].each { |stub| proxy.remove_single_stub(method_name, stub) }
-          end
           stubs[method_name].clear
           stop_observing!(method_name) unless message_chains.has_expectation?(method_name)
         end
@@ -97,9 +91,6 @@ module RSpec
           if @expectation_set && !message_chains.all_expectations_fulfilled?
             raise RSpec::Mocks::MockExpectationError, "Exactly one instance should have received the following message(s) but didn't: #{message_chains.unfulfilled_expectations.sort.join(', ')}"
           end
-        ensure
-          stop_all_observation!
-          ::RSpec::Mocks.space.remove_any_instance_recorder_for(@klass)
         end
 
         # @private
@@ -120,14 +111,31 @@ module RSpec
           @played_methods[method_name]
         end
 
+        # @private
         def build_alias_method_name(method_name)
           "__#{method_name}_without_any_instance__"
         end
 
+        # @private
         def already_observing?(method_name)
           @observed_methods.include?(method_name) || super_class_observing?(method_name)
         end
 
+        # @private
+        def notify_received_message(object, message, args, blk)
+          has_expectation = false
+
+          message_chains.each_unfulfilled_expectation_matching(message, *args) do |expectation|
+            has_expectation = true
+            expectation.expectation_fulfilled!
+          end
+
+          if has_expectation
+            restore_method!(message)
+            mark_invoked!(message)
+          end
+        end
+
       protected
 
         def stop_observing!(method_name)
@@ -206,8 +214,13 @@ module RSpec
         end
 
         def observe!(method_name)
+          allow_no_prepended_module_definition_of(method_name)
+
           if RSpec::Mocks.configuration.verify_partial_doubles?
-            raise MockExpectationError unless @klass.method_defined?(method_name)
+            unless public_protected_or_private_method_defined?(method_name)
+              raise MockExpectationError,
+                "#{@klass} does not implement ##{method_name}"
+            end
           end
 
           stop_observing!(method_name) if already_observing?(method_name)
@@ -225,9 +238,27 @@ module RSpec
           @klass.__send__(:define_method, method_name) do |*args, &blk|
             klass = ::RSpec::Support.method_handle_for(self, method_name).owner
             invoked_instance = ::RSpec::Mocks.space.any_instance_recorder_for(klass).instance_that_received(method_name)
-            raise RSpec::Mocks::MockExpectationError, "The message '#{method_name}' was received by #{self.inspect} but has already been received by #{invoked_instance}"
+            inspect = "#<#{self.class}:#{object_id} #{instance_variables.map { |name| "#{name}=#{instance_variable_get name}" }.join(', ')}>"
+            raise RSpec::Mocks::MockExpectationError, "The message '#{method_name}' was received by #{inspect} but has already been received by #{invoked_instance}"
           end
         end
+
+        if Support::RubyFeatures.module_prepends_supported?
+          def allow_no_prepended_module_definition_of(method_name)
+            prepended_modules = @klass.ancestors.take_while { |mod| !(Class === mod) }
+            problem_mod = prepended_modules.find { |mod| mod.method_defined?(method_name) }
+            return unless problem_mod
+
+            raise RSpec::Mocks::MockExpectationError,
+              "Using `any_instance` to stub a method (#{method_name}) that has been " +
+              "defined on a prepended module (#{problem_mod}) is not supported."
+          end
+        else
+          def allow_no_prepended_module_definition_of(method_name)
+            # nothing to do; prepends aren't supported on this version of ruby
+          end
+        end
+
       end
     end
   end

data/lib/rspec/mocks/any_instance/stub_chain.rb

@@ -9,12 +9,14 @@ module RSpec
           true
         end
 
-        private
+      private
 
         def create_message_expectation_on(instance)
           proxy = ::RSpec::Mocks.space.proxy_for(instance)
-          expected_from = IGNORED_BACKTRACE_LINE
-          stub = proxy.add_stub(expected_from, *@expectation_args, &@expectation_block)
+          method_name, opts = @expectation_args
+          opts = (opts || {}).merge(:expected_form => IGNORED_BACKTRACE_LINE)
+
+          stub = proxy.add_stub(method_name, opts, &@expectation_block)
           @recorder.stubs[stub.message] << stub
 
           if RSpec::Mocks.configuration.yield_receiver_to_any_instance_implementation_blocks?

data/lib/rspec/mocks/any_instance/stub_chain_chain.rb

@@ -8,7 +8,7 @@ module RSpec
           @expectation_fulfilled = false
         end
 
-        private
+      private
 
         def create_message_expectation_on(instance)
           ::RSpec::Mocks::StubChain.stub_chain_on(instance, *@expectation_args, &@expectation_block)

data/lib/rspec/mocks/argument_list_matcher.rb

@@ -1,3 +1,6 @@
+# We intentionally do not use the `RSpec::Support.require...` methods
+# here so that this file can be loaded individually, as documented
+# below.
 require 'rspec/mocks/argument_matchers'
 require 'rspec/support/fuzzy_matcher'
 
@@ -32,8 +35,7 @@ module RSpec
       attr_reader :expected_args
 
       # @api public
-      # @param [Array] *expected_args a list of expected literals and/or argument matchers
-      # @param [Block] block a block with arity matching the expected
+      # @param [Array] expected_args a list of expected literals and/or argument matchers
       #
       # Initializes an `ArgumentListMatcher` with a collection of literal
       # values and/or argument matchers.
@@ -51,7 +53,7 @@ module RSpec
       end
 
       # @api public
-      # @param [Array] *args
+      # @param [Array] args
       #
       # Matches each element in the `expected_args` against the element in the same
       # position of the arguments passed to `new`.

data/lib/rspec/mocks/argument_matchers.rb

@@ -115,42 +115,50 @@ module RSpec
 
       alias_method :a_kind_of, :kind_of
 
-      # @api private
+      # @private
       def self.anythingize_lonely_keys(*args)
         hash = args.last.class == Hash ? args.delete_at(-1) : {}
         args.each { | arg | hash[arg] = AnyArgMatcher.new }
         hash
       end
 
-      # @api private
+      # @private
       class AnyArgsMatcher
         def description
           "any args"
         end
       end
 
-      # @api private
+      # @private
       class AnyArgMatcher
         def ===(other)
           true
         end
+
+        def description
+          "anything"
+        end
       end
 
-      # @api private
+      # @private
       class NoArgsMatcher
         def description
           "no args"
         end
       end
 
-      # @api private
+      # @private
       class BooleanMatcher
         def ===(value)
           true == value || false == value
         end
+
+        def description
+          "boolean"
+        end
       end
 
-      # @api private
+      # @private
       class BaseHashMatcher
         def initialize(expected)
           @expected = expected
@@ -169,7 +177,7 @@ module RSpec
         end
       end
 
-      # @api private
+      # @private
       class HashIncludingMatcher < BaseHashMatcher
         def ===(actual)
           super(:all?, actual)
@@ -180,7 +188,7 @@ module RSpec
         end
       end
 
-      # @api private
+      # @private
       class HashExcludingMatcher < BaseHashMatcher
         def ===(actual)
           super(:none?, actual)
@@ -191,7 +199,7 @@ module RSpec
         end
       end
 
-      # @api private
+      # @private
       class ArrayIncludingMatcher
         def initialize(expected)
           @expected = expected
@@ -202,11 +210,11 @@ module RSpec
         end
 
         def description
-          "array_including(#{@expected.join(",")})"
+          "array_including(#{@expected.join(", ")})"
         end
       end
 
-      # @api private
+      # @private
       class DuckTypeMatcher
         def initialize(*methods_to_respond_to)
           @methods_to_respond_to = methods_to_respond_to
@@ -215,9 +223,13 @@ module RSpec
         def ===(value)
           @methods_to_respond_to.all? {|message| value.respond_to?(message)}
         end
+
+        def description
+          "duck_type(#{@methods_to_respond_to.map(&:inspect).join(', ')})"
+        end
       end
 
-      # @api private
+      # @private
       class InstanceOf
         def initialize(klass)
           @klass = klass
@@ -226,6 +238,10 @@ module RSpec
         def ===(actual)
           actual.instance_of?(@klass)
         end
+
+        def description
+          "an_instance_of(#{@klass.name})"
+        end
       end
 
     end