rspec-mocks 2.99.4 → 3.0.0.beta1

data/lib/rspec/mocks/object_reference.rb

@@ -0,0 +1,90 @@
+module RSpec
+  module Mocks
+
+    # @api private
+    class ObjectReference
+      # Returns an appropriate Object or Module reference based
+      # on the given argument.
+      def self.for(object_module_or_name, allow_direct_object_refs = false)
+        case object_module_or_name
+          when Module then DirectModuleReference.new(object_module_or_name)
+          when String then NamedObjectReference.new(object_module_or_name)
+          else
+            if allow_direct_object_refs
+              DirectObjectReference.new(object_module_or_name)
+            else
+              raise ArgumentError,
+                "Module or String expected, got #{object_module_or_name.inspect}"
+            end
+        end
+      end
+    end
+
+    # Used when an object is passed to `object_double`.
+    # Represents a reference to that object.
+    # @api private
+    class DirectObjectReference
+      def initialize(object)
+        @object = object
+      end
+
+      def description
+        @object.inspect
+      end
+
+      def const_to_replace
+        raise ArgumentError,
+          "Can not perform constant replacement with an object."
+      end
+
+      def defined?
+        true
+      end
+
+      def when_loaded
+        yield @object
+      end
+    end
+
+    # Used when a module is passed to `class_double` or `instance_double`.
+    # Represents a reference to that module.
+    # @api private
+    class DirectModuleReference < DirectObjectReference
+      def const_to_replace
+        @object.name
+      end
+      alias description const_to_replace
+    end
+
+    # Used when a string is passed to `class_double`, `instance_double`
+    # or `object_double`.
+    # Represents a reference to the object named (via a constant lookup)
+    # by the string.
+    # @api private
+    class NamedObjectReference
+      def initialize(const_name)
+        @const_name = const_name
+      end
+
+      def defined?
+        !!object
+      end
+
+      def const_to_replace
+        @const_name
+      end
+      alias description const_to_replace
+
+      def when_loaded(&block)
+        yield object if object
+      end
+
+   private
+
+      def object
+        @object ||= Constant.original(@const_name).original_value
+      end
+    end
+  end
+end
+

data/lib/rspec/mocks/order_group.rb

@@ -3,38 +3,80 @@ module RSpec
     # @private
     class OrderGroup
       def initialize
-        @ordering = Array.new
+        @expectations = []
+        @invocation_order = []
+        @index = 0
       end
 
       # @private
       def register(expectation)
-        @ordering << expectation
+        @expectations << expectation
+      end
+
+      def invoked(message)
+        @invocation_order << message
       end
 
       # @private
       def ready_for?(expectation)
-        @ordering.first == expectation
+        remaining_expectations.find(&:ordered?) == expectation
       end
 
       # @private
       def consume
-        @ordering.shift
+        remaining_expectations.each_with_index do |expectation, index|
+          if expectation.ordered?
+            @index += index + 1
+            return expectation
+          end
+        end
+        nil
       end
 
       # @private
       def handle_order_constraint(expectation)
-        return unless @ordering.include?(expectation)
+        return unless expectation.ordered? && remaining_expectations.include?(expectation)
         return consume if ready_for?(expectation)
         expectation.raise_out_of_order_error
       end
 
+      def verify_invocation_order(expectation)
+        expectation.raise_out_of_order_error unless expectations_invoked_in_order?
+        true
+      end
+
       def clear
-        @ordering.clear
+        @index = 0
+        @invocation_order.clear
+        @expectations.clear
       end
 
       def empty?
-        @ordering.empty?
+        @expectations.empty?
+      end
+
+    private
+
+      def remaining_expectations
+        @expectations[@index..-1] || []
+      end
+
+      def expectations_invoked_in_order?
+        invoked_expectations == expected_invocations
+      end
+
+      def invoked_expectations
+        @expectations.select { |e| e.ordered? && @invocation_order.include?(e) }
+      end
+
+      def expected_invocations
+        @invocation_order.map { |invocation| expectation_for(invocation) }.compact
+      end
+
+      def expectation_for(message)
+        @expectations.find { |e| message == e }
       end
+
     end
   end
 end

data/lib/rspec/mocks/proxy.rb

@@ -2,17 +2,23 @@ module RSpec
   module Mocks
     # @private
     class Proxy
+      SpecificMessage = Struct.new(:object,:message) do
+        def ==(expectation)
+          expectation.orig_object == object && expectation.message == message
+        end
+      end
 
       # @private
-      def initialize(object, name=nil, options={})
+      def initialize(object, order_group, name=nil, options={})
         @object = object
+        @order_group = order_group
         @name = name
-        @error_generator = ErrorGenerator.new object, name, options
+        @error_generator = ErrorGenerator.new(object, name)
         @expectation_ordering = RSpec::Mocks::space.expectation_ordering
         @messages_received = []
         @options = options
-        @already_proxied_respond_to = false
         @null_object = false
+        @method_doubles = Hash.new { |h, k| h[k] = MethodDouble.new(@object, k, self) }
       end
 
       # @private
@@ -32,18 +38,13 @@ module RSpec
       end
 
       # @private
-      def already_proxied_respond_to
-        @already_proxied_respond_to = true
-      end
-
-      # @private
-      def already_proxied_respond_to?
-        @already_proxied_respond_to
+      def method_handle_for(message)
+        nil
       end
 
       # @private
       def add_message_expectation(location, method_name, opts={}, &block)
-        meth_double = method_double[method_name]
+        meth_double = method_double_for(method_name)
 
         if null_object? && !block
           meth_double.add_default_stub(@error_generator, @expectation_ordering, location, opts) do
@@ -54,9 +55,14 @@ module RSpec
         meth_double.add_expectation @error_generator, @expectation_ordering, location, opts, &block
       end
 
+      # @private
+      def add_simple_expectation(method_name, response, location)
+        method_double_for(method_name).add_simple_expectation method_name, response, @error_generator, location
+      end
+
       # @private
       def build_expectation(method_name)
-        meth_double = method_double[method_name]
+        meth_double = method_double_for(method_name)
 
         meth_double.build_expectation(
           @error_generator,
@@ -65,9 +71,9 @@ module RSpec
       end
 
       # @private
-      def replay_received_message_on(expectation)
+      def replay_received_message_on(expectation, &block)
         expected_method_name = expectation.message
-        meth_double = method_double[expected_method_name]
+        meth_double = method_double_for(expected_method_name)
 
         if meth_double.expectations.any?
           @error_generator.raise_expectation_on_mocked_method(expected_method_name)
@@ -80,8 +86,10 @@ module RSpec
         @messages_received.each do |(actual_method_name, args, _)|
           if expectation.matches?(actual_method_name, *args)
             expectation.invoke(nil)
+            block.call(*args) if block
           end
         end
+
       end
 
       # @private
@@ -95,28 +103,34 @@ module RSpec
 
       # @private
       def add_stub(location, method_name, opts={}, &implementation)
-        method_double[method_name].add_stub @error_generator, @expectation_ordering, location, opts, &implementation
+        method_double_for(method_name).add_stub @error_generator, @expectation_ordering, location, opts, &implementation
+      end
+
+      # @private
+      def add_simple_stub(method_name, response)
+        method_double_for(method_name).add_simple_stub method_name, response
       end
 
       # @private
       def remove_stub(method_name)
-        method_double[method_name].remove_stub
+        method_double_for(method_name).remove_stub
       end
 
+      # @private
       def remove_single_stub(method_name, stub)
-        method_double[method_name].remove_single_stub(stub)
+        method_double_for(method_name).remove_single_stub(stub)
       end
 
       # @private
       def verify
-        method_doubles.each {|d| d.verify}
+        @method_doubles.each_value {|d| d.verify}
       ensure
         reset
       end
 
       # @private
       def reset
-        method_doubles.each {|d| d.reset}
+        @method_doubles.each_value {|d| d.reset}
         @messages_received.clear
       end
 
@@ -127,11 +141,12 @@ module RSpec
 
       # @private
       def has_negative_expectation?(message)
-        method_double[message].expectations.detect {|expectation| expectation.negative_expectation_for?(message)}
+        method_double_for(message).expectations.detect {|expectation| expectation.negative_expectation_for?(message)}
       end
 
       # @private
       def record_message_received(message, *args, &block)
+        @order_group.invoked SpecificMessage.new(object, message)
         @messages_received << [message, args, block]
       end
 
@@ -155,7 +170,7 @@ module RSpec
         elsif stub = find_almost_matching_stub(message, *args)
           stub.advise(*args)
           raise_missing_default_stub_error(stub, *args)
-        elsif @object.is_a?(Class)
+        elsif Class === @object
           @object.superclass.__send__(message, *args, &block)
         else
           @object.__send__(:method_missing, message, *args, &block)
@@ -179,12 +194,8 @@ module RSpec
 
       private
 
-      def method_double
-        @method_double ||= Hash.new {|h,k| h[k] = MethodDouble.new(@object, k, self) }
-      end
-
-      def method_doubles
-        method_double.values
+      def method_double_for(message)
+        @method_doubles[message.to_sym]
       end
 
       def find_matching_expectation(method_name, *args)
@@ -202,7 +213,7 @@ module RSpec
       def find_best_matching_expectation_for(method_name)
         first_match = nil
 
-        method_double[method_name].expectations.each do |expectation|
+        method_double_for(method_name).expectations.each do |expectation|
           next unless yield expectation
           return expectation unless expectation.called_max_times?
           first_match ||= expectation
@@ -212,19 +223,47 @@ module RSpec
       end
 
       def find_matching_method_stub(method_name, *args)
-        method_double[method_name].stubs.find {|stub| stub.matches?(method_name, *args)}
+        method_double_for(method_name).stubs.find {|stub| stub.matches?(method_name, *args)}
       end
 
       def find_almost_matching_stub(method_name, *args)
-        method_double[method_name].stubs.find {|stub| stub.matches_name_but_not_args(method_name, *args)}
+        method_double_for(method_name).stubs.find {|stub| stub.matches_name_but_not_args(method_name, *args)}
       end
     end
 
-    class TestDoubleProxy < Proxy
-      def reset
-        object.__warn_if_used_further!
+    class PartialMockProxy < Proxy
+      def method_handle_for(message)
+        if any_instance_class_recorder_observing_method?(@object.class, message)
+          message = ::RSpec::Mocks.
+            any_instance_recorder_for(@object.class).
+            build_alias_method_name(message)
+        end
+
+        ::RSpec::Mocks.method_handle_for(@object, message)
+      rescue NameError
+        nil
+      end
+
+      # @private
+      def add_simple_expectation(method_name, response, location)
+        method_double_for(method_name).configure_method
         super
       end
+
+      # @private
+      def add_simple_stub(method_name, response)
+        method_double_for(method_name).configure_method
+        super
+      end
+
+    private
+
+      def any_instance_class_recorder_observing_method?(klass, method_name)
+        return true if ::RSpec::Mocks.any_instance_recorder_for(klass).already_observing?(method_name)
+        superklass = klass.superclass
+        return false if superklass.nil?
+        any_instance_class_recorder_observing_method?(superklass, method_name)
+      end
     end
   end
 end

data/lib/rspec/mocks/proxy_for_nil.rb

@@ -3,9 +3,9 @@ module RSpec
     # @private
     class ProxyForNil < Proxy
 
-      def initialize
+      def initialize(order_group)
         @warn_about_expectations = true
-        super nil
+        super nil, order_group
       end
       attr_accessor :warn_about_expectations
       alias warn_about_expectations? warn_about_expectations

data/lib/rspec/mocks/space.rb

@@ -2,13 +2,11 @@ module RSpec
   module Mocks
     # @api private
     class Space
-      attr_reader   :proxies, :any_instance_recorders
-      attr_accessor :outside_example
+      attr_reader :proxies, :any_instance_recorders
 
       def initialize
         @proxies                 = {}
         @any_instance_recorders  = {}
-        self.outside_example     = true
       end
 
       def verify_all
@@ -29,11 +27,6 @@ module RSpec
         end
 
         proxies.clear
-
-        any_instance_recorders.each_value do |recorder|
-          recorder.stop_all_observation!
-        end
-
         any_instance_recorders.clear
         expectation_ordering.clear
       end
@@ -43,26 +36,32 @@ module RSpec
       end
 
       def any_instance_recorder_for(klass)
-        print_out_of_example_deprecation if outside_example
         id = klass.__id__
         any_instance_recorders.fetch(id) do
           any_instance_recorders[id] = AnyInstance::Recorder.new(klass)
         end
       end
 
+      def remove_any_instance_recorder_for(klass)
+        any_instance_recorders.delete(klass.__id__)
+      end
+
       def proxies_of(klass)
         proxies.values.select { |proxy| klass === proxy.object }
       end
 
       def proxy_for(object)
-        print_out_of_example_deprecation if outside_example
         id = id_for(object)
         proxies.fetch(id) do
           proxies[id] = case object
-                        when NilClass   then ProxyForNil.new
-                        when TestDouble then object.__build_mock_proxy
+                        when NilClass   then ProxyForNil.new(expectation_ordering)
+                        when TestDouble then object.__build_mock_proxy(expectation_ordering)
                         else
-                          Proxy.new(object)
+                          if RSpec::Mocks.configuration.verify_partial_doubles?
+                            VerifyingPartialMockProxy.new(object, expectation_ordering)
+                          else
+                            PartialMockProxy.new(object, expectation_ordering)
+                          end
                         end
         end
       end
@@ -73,10 +72,6 @@ module RSpec
         proxies.has_key?(id_for object)
       end
 
-      def print_out_of_example_deprecation
-        RSpec.deprecate("Using rspec-mocks doubles or partial doubles outside the per-test lifecycle (such as in a `before(:all)` hook)")
-      end
-
       if defined?(::BasicObject) && !::BasicObject.method_defined?(:__id__) # for 1.9.2
         require 'securerandom'
 
@@ -86,7 +81,7 @@ module RSpec
           return id if object.equal?(::ObjectSpace._id2ref(id))
           # this suggests that object.__id__ is proxying through to some wrapped object
 
-          object.instance_eval do
+          object.instance_exec do
             @__id_for_rspec_mocks_space ||= ::SecureRandom.uuid
           end
         end