rspec-mocks 2.11.3 → 3.11.1

data/lib/rspec/mocks/space.rb

@@ -1,33 +1,237 @@
+RSpec::Support.require_rspec_support 'reentrant_mutex'
+
 module RSpec
   module Mocks
-    # @api private
+    # @private
+    # Provides a default space implementation for outside
+    # the scope of an example. Called "root" because it serves
+    # as the root of the space stack.
+    class RootSpace
+      def proxy_for(*_args)
+        raise_lifecycle_message
+      end
+
+      def any_instance_recorder_for(*_args)
+        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
+
+      def verify_all
+      end
+
+      def registered?(_object)
+        false
+      end
+
+      def superclass_proxy_for(*_args)
+        raise_lifecycle_message
+      end
+
+      def new_scope
+        Space.new
+      end
+
+    private
+
+      def raise_lifecycle_message
+        raise OutsideOfExampleError,
+              "The use of doubles or partial doubles from rspec-mocks outside of the per-test lifecycle is not supported."
+      end
+    end
+
+    # @private
     class Space
-      def add(obj)
-        receivers << obj unless receivers.detect {|m| m.equal? obj}
+      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
+        NestedSpace.new(self)
       end
 
       def verify_all
-        receivers.each do |mock|
-          mock.rspec_verify
-        end
+        proxies.values.each { |proxy| proxy.verify }
+        any_instance_recorders.each_value { |recorder| recorder.verify }
       end
 
       def reset_all
-        receivers.each do |mock|
-          mock.rspec_reset
+        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)
+        @constant_mutators << mutator
+      end
+
+      def constant_mutator_for(name)
+        @constant_mutators.find { |m| m.full_constant_name == name }
+      end
+
+      def any_instance_recorder_for(klass, only_return_existing=false)
+        any_instance_mutex.synchronize do
+          id = klass.__id__
+          any_instance_recorders.fetch(id) do
+            return nil if only_return_existing
+            any_instance_recorder_not_found_for(id, klass)
+          end
+        end
+      end
+
+      def any_instance_proxy_for(klass)
+        AnyInstance::Proxy.new(any_instance_recorder_for(klass), proxies_of(klass))
+      end
+
+      def proxies_of(klass)
+        proxies.values.select { |proxy| klass === proxy.object }
+      end
+
+      def proxy_for(object)
+        proxy_mutex.synchronize do
+          id = id_for(object)
+          proxies.fetch(id) { proxy_not_found_for(id, object) }
+        end
+      end
+
+      def superclass_proxy_for(klass)
+        proxy_mutex.synchronize do
+          id = id_for(klass)
+          proxies.fetch(id) { superclass_proxy_not_found_for(id, klass) }
+        end
+      end
+
+      alias ensure_registered proxy_for
+
+      def registered?(object)
+        proxies.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?
+
+        # We access the ancestors through the singleton class, to avoid calling
+        # `class` in case `class` has been stubbed.
+        (class << object; ancestors; end).map do |klass|
+          any_instance_recorders[klass.__id__]
+        end.compact
+      end
+
+    private
+
+      def new_mutex
+        Support::ReentrantMutex.new
+      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_unless_expired(@expectation_ordering)
+                      when Class
+                        class_proxy_with_callback_verification_strategy(object, CallbackInvocationStrategy.new)
+                      else
+                        if RSpec::Mocks.configuration.verify_partial_doubles?
+                          VerifyingPartialDoubleProxy.new(object, @expectation_ordering)
+                        else
+                          PartialDoubleProxy.new(object, @expectation_ordering)
+                        end
+                      end
+      end
+
+      def superclass_proxy_not_found_for(id, object)
+        raise "superclass_proxy_not_found_for called with something that is not a class" unless Class === object
+        proxies[id] = class_proxy_with_callback_verification_strategy(object, NoCallbackInvocationStrategy.new)
+      end
+
+      def class_proxy_with_callback_verification_strategy(object, strategy)
+        if RSpec::Mocks.configuration.verify_partial_doubles?
+          VerifyingPartialClassDoubleProxy.new(
+            self,
+            object,
+            @expectation_ordering,
+            strategy
+          )
+        else
+          PartialClassDoubleProxy.new(self, object, @expectation_ordering)
         end
-        receivers.clear
-        expectation_ordering.clear
       end
 
-      def expectation_ordering
-        @expectation_ordering ||= OrderGroup.new
+      def any_instance_recorder_not_found_for(id, klass)
+        any_instance_recorders[id] = AnyInstance::Recorder.new(klass)
+      end
+
+      if defined?(::BasicObject) && !::BasicObject.method_defined?(:__id__) # for 1.9.2
+        require 'securerandom'
+
+        def id_for(object)
+          id = object.__id__
+
+          return id if object.equal?(::ObjectSpace._id2ref(id))
+          # this suggests that object.__id__ is proxying through to some wrapped object
+
+          object.instance_exec do
+            @__id_for_rspec_mocks_space ||= ::SecureRandom.uuid
+          end
+        end
+      else
+        def id_for(object)
+          object.__id__
+        end
+      end
+    end
+
+    # @private
+    class NestedSpace < Space
+      def initialize(parent)
+        @parent = parent
+        super()
+      end
+
+      def proxies_of(klass)
+        super + @parent.proxies_of(klass)
+      end
+
+      def constant_mutator_for(name)
+        super || @parent.constant_mutator_for(name)
+      end
+
+      def registered?(object)
+        super || @parent.registered?(object)
       end
 
     private
-    
-      def receivers
-        @receivers ||= []
+
+      def proxy_not_found_for(id, object)
+        @parent.proxies[id] || super
+      end
+
+      def any_instance_recorder_not_found_for(id, klass)
+        @parent.any_instance_recorders[id] || super
       end
     end
   end

data/lib/rspec/mocks/standalone.rb

@@ -1,3 +1,3 @@
 require 'rspec/mocks'
-
-RSpec::Mocks.setup(self)
+extend RSpec::Mocks::ExampleMethods
+RSpec::Mocks.setup

data/lib/rspec/mocks/syntax.rb

@@ -0,0 +1,325 @@
+module RSpec
+  module Mocks
+    # @api private
+    # Provides methods for enabling and disabling the available syntaxes
+    # provided by rspec-mocks.
+    module Syntax
+      # @private
+      def self.warn_about_should!
+        @warn_about_should = true
+      end
+
+      # @private
+      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",
+            :replacement => replacement
+          )
+
+          @warn_about_should = false
+        end
+      end
+
+      # @api private
+      # Enables the should syntax (`dbl.stub`, `dbl.should_receive`, etc).
+      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)
+
+        syntax_host.class_exec do
+          def should_receive(message, opts={}, &block)
+            ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
+            ::RSpec::Mocks.expect_message(self, message, opts, &block)
+          end
+
+          def should_not_receive(message, &block)
+            ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
+            ::RSpec::Mocks.expect_message(self, message, {}, &block).never
+          end
+
+          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 }
+            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.space.proxy_for(self).remove_stub(message)
+          end
+
+          def stub_chain(*chain, &blk)
+            ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
+            ::RSpec::Mocks::StubChain.stub_chain_on(self, *chain, &blk)
+          end
+
+          def as_null_object
+            ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
+            @_null_object = true
+            ::RSpec::Mocks.space.proxy_for(self).as_null_object
+          end
+
+          def null_object?
+            ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
+            defined?(@_null_object)
+          end
+
+          def received_message?(message, *args, &block)
+            ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
+            ::RSpec::Mocks.space.proxy_for(self).received_message?(message, *args, &block)
+          end
+
+          unless Class.respond_to? :any_instance
+            Class.class_exec do
+              def any_instance
+                ::RSpec::Mocks::Syntax.warn_unless_should_configured(__method__)
+                ::RSpec::Mocks.space.any_instance_proxy_for(self)
+              end
+            end
+          end
+        end
+      end
+
+      # @api private
+      # Disables the should syntax (`dbl.stub`, `dbl.should_receive`, etc).
+      def self.disable_should(syntax_host=default_should_syntax_host)
+        return unless should_enabled?(syntax_host)
+
+        syntax_host.class_exec do
+          undef should_receive
+          undef should_not_receive
+          undef stub
+          undef unstub
+          undef stub_chain
+          undef as_null_object
+          undef null_object?
+          undef received_message?
+        end
+
+        Class.class_exec do
+          undef any_instance
+        end
+      end
+
+      # @api private
+      # Enables the expect syntax (`expect(dbl).to receive`, `allow(dbl).to receive`, etc).
+      def self.enable_expect(syntax_host=::RSpec::Mocks::ExampleMethods)
+        return if expect_enabled?(syntax_host)
+
+        syntax_host.class_exec do
+          def receive(method_name, &block)
+            Matchers::Receive.new(method_name, block)
+          end
+
+          def receive_messages(message_return_value_hash)
+            matcher = Matchers::ReceiveMessages.new(message_return_value_hash)
+            matcher.warn_about_block if block_given?
+            matcher
+          end
+
+          def receive_message_chain(*messages, &block)
+            Matchers::ReceiveMessageChain.new(messages, &block)
+          end
+
+          def allow(target)
+            AllowanceTarget.new(target)
+          end
+
+          def expect_any_instance_of(klass)
+            AnyInstanceExpectationTarget.new(klass)
+          end
+
+          def allow_any_instance_of(klass)
+            AnyInstanceAllowanceTarget.new(klass)
+          end
+        end
+
+        RSpec::Mocks::ExampleMethods::ExpectHost.class_exec do
+          def expect(target)
+            ExpectationTarget.new(target)
+          end
+        end
+      end
+
+      # @api private
+      # Disables the expect syntax (`expect(dbl).to receive`, `allow(dbl).to receive`, etc).
+      def self.disable_expect(syntax_host=::RSpec::Mocks::ExampleMethods)
+        return unless expect_enabled?(syntax_host)
+
+        syntax_host.class_exec do
+          undef receive
+          undef receive_messages
+          undef receive_message_chain
+          undef allow
+          undef expect_any_instance_of
+          undef allow_any_instance_of
+        end
+
+        RSpec::Mocks::ExampleMethods::ExpectHost.class_exec do
+          undef expect
+        end
+      end
+
+      # @api private
+      # Indicates whether or not the should syntax is enabled.
+      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)
+        syntax_host.method_defined?(:allow)
+      end
+
+      # @api private
+      # Determines where the methods like `should_receive`, and `stub` are added.
+      def self.default_should_syntax_host
+        # JRuby 1.7.4 introduces a regression whereby `defined?(::BasicObject) => nil`
+        # yet `BasicObject` still exists and patching onto ::Object breaks things
+        # e.g. SimpleDelegator expectations won't work
+        #
+        # See: https://github.com/jruby/jruby/issues/814
+        if defined?(JRUBY_VERSION) && JRUBY_VERSION == '1.7.4' && RUBY_VERSION.to_f > 1.8
+          return ::BasicObject
+        end
+
+        # On 1.8.7, Object.ancestors.last == Kernel but
+        # things blow up if we include `RSpec::Mocks::Methods`
+        # into Kernel...not sure why.
+        return Object unless defined?(::BasicObject)
+
+        # MacRuby has BasicObject but it's not the root class.
+        return Object unless Object.ancestors.last == ::BasicObject
+
+        ::BasicObject
+      end
+    end
+  end
+end
+
+if defined?(BasicObject)
+  # 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
+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

data/lib/rspec/mocks/targets.rb

@@ -0,0 +1,124 @@
+module RSpec
+  module Mocks
+    # @private
+    module TargetDelegationClassMethods
+      def delegate_to(matcher_method)
+        define_method(:to) do |matcher, &block|
+          unless matcher_allowed?(matcher)
+            raise_unsupported_matcher(:to, matcher)
+          end
+          define_matcher(matcher, matcher_method, &block)
+        end
+      end
+
+      def delegate_not_to(matcher_method, options={})
+        method_name = options.fetch(:from)
+        define_method(method_name) do |matcher, &block|
+          case matcher
+          when Matchers::Receive, Matchers::HaveReceived
+            define_matcher(matcher, matcher_method, &block)
+          when Matchers::ReceiveMessages, Matchers::ReceiveMessageChain
+            raise_negation_unsupported(method_name, matcher)
+          else
+            raise_unsupported_matcher(method_name, matcher)
+          end
+        end
+      end
+
+      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)
+        Matchers::Matcher === matcher
+      end
+
+      def define_matcher(matcher, name, &block)
+        matcher.__send__(name, target, &block)
+      end
+
+      def raise_unsupported_matcher(method_name, matcher)
+        raise UnsupportedMatcherError,
+              "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?"
+      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
+        :expect
+      end
+    end
+
+    # @private
+    class ExpectationTarget < TargetBase
+      include ExpectationTargetMethods
+    end
+
+    # @private
+    class AllowanceTarget < TargetBase
+      def expression
+        :allow
+      end
+
+      delegate_to :setup_allowance
+      disallow_negation :not_to
+      disallow_negation :to_not
+    end
+
+    # @private
+    class AnyInstanceAllowanceTarget < TargetBase
+      def expression
+        :allow_any_instance_of
+      end
+
+      delegate_to :setup_any_instance_allowance
+      disallow_negation :not_to
+      disallow_negation :to_not
+    end
+
+    # @private
+    class AnyInstanceExpectationTarget < TargetBase
+      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
+    end
+  end
+end