rspec-mocks 3.0.0.beta2 → 3.0.0.rc1

data/lib/rspec/mocks/space.rb

@@ -13,10 +13,18 @@ module RSpec
         raise_lifecycle_message
       end
 
+      def any_instance_proxy_for(*args)
+        raise_lifecycle_message
+      end
+
       def register_constant_mutator(mutator)
         raise_lifecycle_message
       end
 
+      def any_instance_recorders_from_ancestry_of(object)
+        raise_lifecycle_message
+      end
+
       def reset_all
       end
 
@@ -39,15 +47,17 @@ module RSpec
       end
     end
 
-    # @api private
+    # @private
     class Space
-      attr_reader :proxies, :any_instance_recorders, :expectation_ordering
+      attr_reader :proxies, :any_instance_recorders, :proxy_mutex, :any_instance_mutex
 
       def initialize
         @proxies                 = {}
         @any_instance_recorders  = {}
         @constant_mutators       = []
         @expectation_ordering    = OrderGroup.new
+        @proxy_mutex             = new_mutex
+        @any_instance_mutex      = new_mutex
       end
 
       def new_scope
@@ -62,6 +72,8 @@ module RSpec
       def reset_all
         proxies.each_value { |proxy| proxy.reset }
         @constant_mutators.reverse.each { |mut| mut.idempotently_reset }
+        any_instance_recorders.each_value { |recorder| recorder.stop_all_observation! }
+        any_instance_recorders.clear
       end
 
       def register_constant_mutator(mutator)
@@ -73,14 +85,16 @@ module RSpec
       end
 
       def any_instance_recorder_for(klass)
-        id = klass.__id__
-        any_instance_recorders.fetch(id) do
-          any_instance_recorder_not_found_for(id, klass)
+        any_instance_mutex.synchronize do
+          id = klass.__id__
+          any_instance_recorders.fetch(id) do
+            any_instance_recorder_not_found_for(id, klass)
+          end
         end
       end
 
-      def remove_any_instance_recorder_for(klass)
-        any_instance_recorders.delete(klass.__id__)
+      def any_instance_proxy_for(klass)
+        AnyInstance::Proxy.new(any_instance_recorder_for(klass), proxies_of(klass))
       end
 
       def proxies_of(klass)
@@ -88,8 +102,10 @@ module RSpec
       end
 
       def proxy_for(object)
-        id = id_for(object)
-        proxies.fetch(id) { proxy_not_found_for(id, object) }
+        proxy_mutex.synchronize do
+          id = id_for(object)
+          proxies.fetch(id) { proxy_not_found_for(id, object) }
+        end
       end
 
       alias ensure_registered proxy_for
@@ -98,12 +114,44 @@ module RSpec
         proxies.has_key?(id_for object)
       end
 
+      def any_instance_recorders_from_ancestry_of(object)
+        # Optimization: `any_instance` is a feature we generally
+        # recommend not using, so we can often early exit here
+        # without doing an O(N) linear search over the number of
+        # ancestors in the object's class hierarchy.
+        return [] if any_instance_recorders.empty?
+
+        object.class.ancestors.map do |klass|
+          any_instance_recorders[klass.__id__]
+        end.compact
+      end
+
     private
 
+      # We don't want to depend on the stdlib ourselves, but if the user is
+      # using threads then a Mutex will be available to us. If not, we don't
+      # need to synchronize anyway.
+      def new_mutex
+        defined?(::Mutex) ? ::Mutex.new : FakeMutex
+      end
+
+      # @private
+      module FakeMutex
+        def self.synchronize
+          yield
+        end
+      end
+
       def proxy_not_found_for(id, object)
         proxies[id] = case object
           when NilClass   then ProxyForNil.new(@expectation_ordering)
           when TestDouble then object.__build_mock_proxy(@expectation_ordering)
+          when Class
+            if RSpec::Mocks.configuration.verify_partial_doubles?
+              VerifyingPartialClassDoubleProxy.new(self, object, @expectation_ordering)
+            else
+              PartialClassDoubleProxy.new(self, object, @expectation_ordering)
+            end
           else
             if RSpec::Mocks.configuration.verify_partial_doubles?
               VerifyingPartialDoubleProxy.new(object, @expectation_ordering)
@@ -137,6 +185,7 @@ module RSpec
       end
     end
 
+    # @private
     class NestedSpace < Space
       def initialize(parent)
         @parent = parent

data/lib/rspec/mocks/syntax.rb

@@ -4,12 +4,12 @@ module RSpec
     # Provides methods for enabling and disabling the available syntaxes
     # provided by rspec-mocks.
     module Syntax
-      # @api private
+      # @private
       def self.warn_about_should!
         @warn_about_should = true
       end
 
-      # @api private
+      # @private
       def self.warn_unless_should_configured(method_name ,replacement = "the new `:expect` syntax or explicitly enable `:should`")
         if @warn_about_should
           RSpec.deprecate(
@@ -30,14 +30,12 @@ module RSpec
         syntax_host.class_exec do
           def should_receive(message, opts={}, &block)
             ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
-            opts[:expected_from] ||= CallerFilter.first_non_rspec_line
             ::RSpec::Mocks.expect_message(self, message, opts, &block)
           end
 
           def should_not_receive(message, &block)
             ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
-            opts = {:expected_from => CallerFilter.first_non_rspec_line}
-            ::RSpec::Mocks.expect_message(self, message, opts, &block).never
+            ::RSpec::Mocks.expect_message(self, message, {}, &block).never
           end
 
           def stub(message_or_hash, opts={}, &block)
@@ -45,7 +43,6 @@ module RSpec
             if ::Hash === message_or_hash
               message_or_hash.each {|message, value| stub(message).and_return value }
             else
-              opts[:expected_from] = CallerFilter.first_non_rspec_line
               ::RSpec::Mocks.allow_message(self, message_or_hash, opts, &block)
             end
           end
@@ -80,7 +77,7 @@ module RSpec
             Class.class_exec do
               def any_instance
                 ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
-                ::RSpec::Mocks.space.any_instance_recorder_for(self)
+                ::RSpec::Mocks.space.any_instance_proxy_for(self)
               end
             end
           end
@@ -201,209 +198,130 @@ module RSpec
 
         ::BasicObject
       end
-
-      # @method should_receive
-      # Sets an expectation that this object should receive a message before
-      # 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
-      #
-      # @note This is only available when you have enabled the `should` syntax.
-
-      # @method should_not_receive
-      # Sets and expectation that this object should _not_ receive a message
-      # during this example.
-
-      # @method stub
-      # 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 }
-      #
-      # @note This is only available when you have enabled the `should` syntax.
-
-      # @method unstub
-      # Removes a stub. On a double, the object will no longer respond to
-      # `message`. On a real object, the original method (if it exists) is
-      # restored.
-      #
-      # This is rarely used, but can be useful when a stub is set up during a
-      # shared `before` hook for the common case, but you want to replace it
-      # for a special case.
-      #
-      # @note This is only available when you have enabled the `should` syntax.
-
-      # @method stub_chain
-      # @overload stub_chain(method1, method2)
-      # @overload stub_chain("method1.method2")
-      # @overload stub_chain(method1, method_to_value_hash)
-      #
-      # Stubs a chain of methods.
-      #
-      # ## Warning:
-      #
-      # Chains can be arbitrarily long, which makes it quite painless to
-      # violate the Law of Demeter in violent ways, so you should consider any
-      # use of `stub_chain` a code smell. Even though not all code smells
-      # indicate real problems (think fluent interfaces), `stub_chain` still
-      # results in brittle examples.  For example, if you write
-      # `foo.stub_chain(:bar, :baz => 37)` in a spec and then the
-      # 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 }
-      #
-      #     # Given any of ^^ these three forms ^^:
-      #     double.foo.bar # => :baz
-      #
-      #     # Common use in Rails/ActiveRecord:
-      #     Article.stub_chain("recent.published") { [Article.new] }
-      #
-      # @note This is only available when you have enabled the `should` syntax.
-
-      # @method as_null_object
-      # Tells the object to respond to all messages. If specific stub values
-      # are declared, they'll work as expected. If not, the receiver is
-      # returned.
-      #
-      # @note This is only available when you have enabled the `should` syntax.
-
-      # @method null_object?
-      # Returns true if this object has received `as_null_object`
-      #
-      # @note This is only available when you have enabled the `should` syntax.
-
-      # @method any_instance
-      # Used to set stubs and message expectations on any instance of a given
-      # class. Returns a [Recorder](Recorder), which records messages like
-      # `stub` and `should_receive` for later playback on instances of the
-      # 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
-      #
-      #     Account.any_instance.stub(:balance) { Money.new(:USD, 25) }
-      #     Account.new.balance # => Money.new(:USD, 25))
-      #
-      # @return [Recorder]
-      #
-      # @note This is only available when you have enabled the `should` syntax.
-
-      # @method expect
-      # Used to wrap an object in preparation for setting a mock expectation
-      # on it.
-      #
-      # @example
-      #
-      #   expect(obj).to receive(:foo).with(5).and_return(:return_value)
-      #
-      # @note This method is usually provided by rspec-expectations, unless
-      #   you are using rspec-mocks w/o rspec-expectations, in which case it
-      #   is only made available if you enable the `expect` syntax.
-
-      # @method allow
-      # Used to wrap an object in preparation for stubbing a method
-      # on it.
-      #
-      # @example
-      #
-      #   allow(dbl).to receive(:foo).with(5).and_return(:return_value)
-      #
-      # @note This is only available when you have enabled the `expect` syntax.
-
-      # @method expect_any_instance_of
-      # Used to wrap a class in preparation for setting a mock expectation
-      # on instances of it.
-      #
-      # @example
-      #
-      #   expect_any_instance_of(MyClass).to receive(:foo)
-      #
-      # @note This is only available when you have enabled the `expect` syntax.
-
-      # @method allow_any_instance_of
-      # Used to wrap a class in preparation for stubbing a method
-      # on instances of it.
-      #
-      # @example
-      #
-      #   allow_any_instance_of(MyClass).to receive(:foo)
-      #
-      # @note This is only available when you have enabled the `expect` syntax.
-
-      # @method receive
-      # Used to specify a message that you expect or allow an object
-      # to receive. The object returned by `receive` supports the same
-      # fluent interface that `should_receive` and `stub` have always
-      # supported, allowing you to constrain the arguments or number of
-      # times, and configure how the object should respond to the message.
-      #
-      # @example
-      #
-      #   expect(obj).to receive(:hello).with("world").exactly(3).times
-      #
-      # @note This is only available when you have enabled the `expect` syntax.
-      #
-      # @method receive_messages
-      # Shorthand syntax used to setup message(s), and their return value(s),
-      # that you expect or allow an object to receive. The method takes a hash
-      # of messages and their respective return values. Unlike with `receive`,
-      # you cannot apply further customizations using a block or the fluent
-      # interface.
-      #
-      # @example
-      #
-      #   allow(obj).to receive_messages(:speak => "Hello World")
-      #   allow(obj).to receive_messages(:speak => "Hello", :meow => "Meow")
-      #
-      # @note This is only available when you have enabled the `expect` syntax.
-      #
-      # @method receive_message_chain
-      # @overload receive_message_chain(method1, method2)
-      # @overload receive_message_chain("method1.method2")
-      # @overload receive_message_chain(method1, method_to_value_hash)
-      #
-      # stubs/mocks a chain of messages on an object or test double.
-      #
-      # ## Warning:
-      #
-      # Chains can be arbitrarily long, which makes it quite painless to
-      # violate the Law of Demeter in violent ways, so you should consider any
-      # use of `receive_message_chain` a code smell. Even though not all code smells
-      # indicate real problems (think fluent interfaces), `receive_message_chain` still
-      # results in brittle examples.  For example, if you write
-      # `foo.receive_message_chain(:bar, :baz => 37)` in a spec and then the
-      # implementation calls `foo.baz.bar`, the stub will not work.
-      #
-      # @example
-      #
-      #     allow(double).to receive_message_chain("foo.bar") { :baz }
-      #     allow(double).to receive_message_chain(:foo, :bar => :baz)
-      #     allow(double).to receive_message_chain(:foo, :bar) { :baz }
-      #
-      #     # Given any of ^^ these three forms ^^:
-      #     double.foo.bar # => :baz
-      #
-      #     # Common use in Rails/ActiveRecord:
-      #     allow(Article).to receive_message_chain("recent.published") { [Article.new] }
-      #
-      # @note This is only available when you have enabled the `expect` syntax.
     end
   end
 end
+
+# The legacy `:should` syntax adds the following methods directly to
+# `BasicObject` so that they are available off of any object. Note, however,
+# that this syntax does not always play nice with delegate/proxy objects.
+# We recommend you use the non-monkeypatching `:expect` syntax instead.
+# @see Class
+class BasicObject
+  # @method should_receive
+  # Sets an expectation that this object should receive a message before
+  # 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
+  #
+  # @note This is only available when you have enabled the `should` syntax.
+  # @see RSpec::Mocks::ExampleMethods#expect
+
+  # @method should_not_receive
+  # Sets and expectation that this object should _not_ receive a message
+  # during this example.
+  # @see RSpec::Mocks::ExampleMethods#expect
+
+  # @method stub
+  # 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 }
+  #
+  # @note This is only available when you have enabled the `should` syntax.
+  # @see RSpec::Mocks::ExampleMethods#allow
+
+  # @method unstub
+  # Removes a stub. On a double, the object will no longer respond to
+  # `message`. On a real object, the original method (if it exists) is
+  # restored.
+  #
+  # This is rarely used, but can be useful when a stub is set up during a
+  # shared `before` hook for the common case, but you want to replace it
+  # for a special case.
+  #
+  # @note This is only available when you have enabled the `should` syntax.
+
+  # @method stub_chain
+  # @overload stub_chain(method1, method2)
+  # @overload stub_chain("method1.method2")
+  # @overload stub_chain(method1, method_to_value_hash)
+  #
+  # Stubs a chain of methods.
+  #
+  # ## Warning:
+  #
+  # Chains can be arbitrarily long, which makes it quite painless to
+  # violate the Law of Demeter in violent ways, so you should consider any
+  # use of `stub_chain` a code smell. Even though not all code smells
+  # indicate real problems (think fluent interfaces), `stub_chain` still
+  # results in brittle examples.  For example, if you write
+  # `foo.stub_chain(:bar, :baz => 37)` in a spec and then the
+  # 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 }
+  #
+  #     # Given any of ^^ these three forms ^^:
+  #     double.foo.bar # => :baz
+  #
+  #     # Common use in Rails/ActiveRecord:
+  #     Article.stub_chain("recent.published") { [Article.new] }
+  #
+  # @note This is only available when you have enabled the `should` syntax.
+  # @see RSpec::Mocks::ExampleMethods#receive_message_chain
+
+  # @method as_null_object
+  # Tells the object to respond to all messages. If specific stub values
+  # are declared, they'll work as expected. If not, the receiver is
+  # returned.
+  #
+  # @note This is only available when you have enabled the `should` syntax.
+
+  # @method null_object?
+  # Returns true if this object has received `as_null_object`
+  #
+  # @note This is only available when you have enabled the `should` syntax.
+end
+
+# The legacy `:should` syntax adds the `any_instance` to `Class`.
+# We generally recommend you use the newer `:expect` syntax instead,
+# which allows you to stub any instance of a class using
+# `allow_any_instance_of(klass)` or mock any instance using
+# `expect_any_instance_of(klass)`.
+# @see BasicObject
+class Class
+  # @method any_instance
+  # Used to set stubs and message expectations on any instance of a given
+  # class. Returns a [Recorder](Recorder), which records messages like
+  # `stub` and `should_receive` for later playback on instances of the
+  # 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
+  #
+  #     Account.any_instance.stub(:balance) { Money.new(:USD, 25) }
+  #     Account.new.balance # => Money.new(:USD, 25))
+  #
+  # @return [Recorder]
+  #
+  # @note This is only available when you have enabled the `should` syntax.
+  # @see RSpec::Mocks::ExampleMethods#expect_any_instance_of
+  # @see RSpec::Mocks::ExampleMethods#allow_any_instance_of
+end