spy 0.1.0 → 0.2.1

data/lib/spy/core_ext/marshal.rb

@@ -1,5 +1,6 @@
 module Marshal
   class << self
+    # @private
     def dump_with_mocks(*args)
       object = args.shift
       spies = Spy::Subroutine.get_spies(object)

data/lib/spy/double.rb

@@ -7,5 +7,22 @@ module Spy
         Spy.on(self,*args)
       end
     end
+
+    # @private
+    def ==(other)
+      other == self
+    end
+
+    # @private
+    def inspect
+      "#<#{self.class}:#{sprintf '0x%x', self.object_id} @name=#{@name.inspect}>"
+    end
+
+    # @private
+    def to_s
+      inspect.gsub('<','[').gsub('>',']')
+    end
+
+    alias_method :to_str, :to_s
   end
 end

data/lib/spy/nest.rb

@@ -1,5 +1,14 @@
 module Spy
+  # This class manages all the Constant Mutations for a given Module
   class Nest
+
+    # @!attribute [r] base_module
+    #   @return [Module] The module that the Nest is managing
+    #
+    # @!attribute [r] hooked_constants
+    #   @return [Hash<Symbol, Constant>] The module that the Nest is managing
+
+
     attr_reader :base_module, :hooked_constants
 
     def initialize(base_module)
@@ -8,6 +17,9 @@ module Spy
       @hooked_constants = {}
     end
 
+    # records that the spy is hooked
+    # @param spy [Constant]
+    # @return [self]
     def add(spy)
       if @hooked_constants[spy.constant_name]
         raise "#{spy.constant_name} has already been stubbed"
@@ -17,6 +29,9 @@ module Spy
       self
     end
 
+    # removes the spy from the records
+    # @param spy [Constant]
+    # @return [self]
     def remove(spy)
       if @hooked_constants[spy.constant_name] == spy
         @hooked_constants.delete(spy.constant_name)
@@ -24,19 +39,31 @@ module Spy
       self
     end
 
+    # checks to see if a given constant is hooked
+    # @param constant_name [Symbol]
+    # @return [Boolean]
     def hooked?(constant_name)
       !!@hooked_constants[constant_name]
     end
 
     class << self
+      # retrieves the nest for a given module
+      # @param base_module [Module]
+      # @return [Nil, Nest]
       def get(base_module)
         all[base_module.name]
       end
 
+
+      # retrieves the nest for a given module or creates it
+      # @param base_module [Module]
+      # @return [Nest]
       def fetch(base_module)
         all[base_module.name] ||= self.new(base_module)
       end
 
+      # returns all the hooked constants
+      # @return [Hash<String, Constant>]
       def all
         @all ||= {}
       end

data/lib/spy/subroutine.rb

@@ -1,55 +1,69 @@
 module Spy
   class Subroutine
-    CallLog = Struct.new(:object, :args, :block, :result)
-    attr_reader :base_object, :method_name, :calls, :original_method, :opts
+    # @!attribute [r] base_object
+    #   @return [Object] the object that is being watched
+    #
+    # @!attribute [r] method_name
+    #   @return [Symbol] the name of the method that is being watched
+    #
+    # @!attribute [r] calls
+    #   @return [Array<CallLog>] the messages that have been sent to the method
+    #
+    # @!attribute [r] original_method
+    #   @return [Method] the original method that was hooked if it existed
+    #
+    # @!attribute [r] hook_opts
+    #   @return [Hash] the options that were sent when it was hooked
+
+
+    attr_reader :base_object, :method_name, :calls, :original_method, :hook_opts
 
     # set what object and method the spy should watch
     # @param object
     # @param method_name <Symbol>
-    def initialize(object, method_name)
-      @was_hooked = false
+    # @param singleton_method <Boolean> spy on the singleton method or the normal method
+    def initialize(object, method_name, singleton_method = true)
       @base_object, @method_name = object, method_name
+      @singleton_method = singleton_method
       reset!
     end
 
     # hooks the method into the object and stashes original method if it exists
-    # @param opts [Hash{force => false, visibility => nil}] set :force => true if you want it to ignore if the method exists, or visibility to [:public, :protected, :private] to overwride current visibility
-    # @return self
+    # @param [Hash] opts what do do when hooking into a method
+    # @option opts [Boolean] force (false) if set to true will hook the method even if it doesn't exist
+    # @option opts [Symbol<:public, :protected, :private>] visibility overrides visibility with whatever method is given
+    # @return [self]
     def hook(opts = {})
-      @opts = opts
+      @hook_opts = opts
       raise "#{base_object} method '#{method_name}' has already been hooked" if hooked?
-      opts[:force] ||= base_object.is_a?(Double)
-      if base_object.respond_to?(method_name, true) || !opts[:force]
-        @original_method = base_object.method(method_name)
+
+      hook_opts[:force] ||= base_object.is_a?(Double)
+      if (base_object_respond_to?(method_name, true)) || !hook_opts[:force]
+        @original_method = current_method
       end
+      hook_opts[:visibility] ||= method_visibility
 
-      opts[:visibility] ||= method_visibility
+      base_object.send(define_method_with, method_name, override_method)
 
-      __method_spy__ = self
-      base_object.define_singleton_method(method_name) do |*__spy_args, &block|
-        if __spy_args.first === SECRET_SPY_KEY
-          __method_spy__
-        else
-          __method_spy__.invoke(self,__spy_args,block)
-        end
+      if [:public, :protected, :private].include? hook_opts[:visibility]
+        method_owner.send(hook_opts[:visibility], method_name)
       end
 
-      base_object.singleton_class.send(opts[:visibility], method_name) if opts[:visibility]
-
       Agency.instance.recruit(self)
       @was_hooked = true
       self
     end
 
     # unhooks method from object
-    # @return self
+    # @return [self]
     def unhook
-      raise "#{method_name} method has not been hooked" unless hooked?
-      if original_method && original_method.owner == base_object.singleton_class
-        base_object.define_singleton_method(method_name, original_method)
-        base_object.singleton_class.send(method_visibility, method_name) if method_visibility
+      raise "'#{method_name}' method has not been hooked" unless hooked?
+
+      if original_method && method_owner == original_method.owner
+        original_method.owner.send(:define_method, method_name, original_method)
+        original_method.owner.send(method_visibility, method_name) if method_visibility
       else
-        base_object.singleton_class.send(:remove_method, method_name)
+        method_owner.send(:remove_method, method_name)
       end
       clear_method!
       Agency.instance.retire(self)
@@ -57,9 +71,9 @@ module Spy
     end
 
     # is the spy hooked?
-    # @return Boolean
+    # @return [Boolean]
     def hooked?
-      self == self.class.get(base_object, method_name)
+      self == self.class.get(base_object, method_name, @singleton_method)
     end
 
     # @overload and_return(value)
@@ -67,7 +81,7 @@ module Spy
     #
     # Tells the spy to return a value when the method is called.
     #
-    # @return self
+    # @return [self]
     def and_return(value = nil)
       if block_given?
         @plan = Proc.new
@@ -88,6 +102,7 @@ module Spy
     end
 
     # Tells the object to yield one or more args to a block when the message is received.
+    # @return [self]
     def and_yield(*args)
       yield eval_context = Object.new if block_given?
       @plan = Proc.new do |&block|
@@ -97,7 +112,7 @@ module Spy
     end
 
     # tells the spy to call the original method
-    # @return self
+    # @return [self]
     def and_call_through
       raise "can only call through if original method is set" unless method_visibility
       if original_method
@@ -110,6 +125,22 @@ module Spy
       self
     end
 
+    # @overload and_raise
+    # @overload and_raise(ExceptionClass)
+    # @overload and_raise(ExceptionClass, message)
+    # @overload and_raise(exception_instance)
+    #
+    # Tells the object to raise an exception when the message is received.
+    #
+    # @note
+    #
+    #   When you pass an exception class, the MessageExpectation will raise
+    #   an instance of it, creating it with `exception` and passing `message`
+    #   if specified.  If the exception class initializer requires more than
+    #   one parameters, you must pass in an instance and not the class,
+    #   otherwise this method will raise an ArgumentError exception.
+    #
+    # @return [self]
     def and_raise(exception = RuntimeError, message = nil)
       if exception.respond_to?(:exception)
         exception = message ? exception.exception(message) : exception.exception
@@ -118,17 +149,28 @@ module Spy
       @plan = Proc.new { raise exception }
     end
 
+    # @overload and_throw(symbol)
+    # @overload and_throw(symbol, object)
+    #
+    # Tells the object to throw a symbol (with the object if that form is
+    # used) when the message is received.
+    #
+    # @return [self]
     def and_throw(*args)
       @plan = Proc.new { throw(*args) }
       self
     end
 
+    # if the method was called it will return true
+    # @return [Boolean]
     def has_been_called?
       raise "was never hooked" unless @was_hooked
       calls.size > 0
     end
 
     # check if the method was called with the exact arguments
+    # @param args Arguments that should have been sent to the method
+    # @return [Boolean]
     def has_been_called_with?(*args)
       raise "was never hooked" unless @was_hooked
       calls.any? do |call_log|
@@ -138,15 +180,16 @@ module Spy
 
     # invoke that the method has been called. You really shouldn't use this
     # method.
-    def invoke(object, args, block)
+    def invoke(object, args, block, called_from)
       check_arity!(args.size)
       result = @plan ? @plan.call(*args, &block) : nil
-      calls << CallLog.new(object, args, block, result)
-      result
+    ensure
+      calls << CallLog.new(object,called_from, args, block, result)
     end
 
     # reset the call log
     def reset!
+      @was_hooked = false
       @calls = []
       clear_method!
       true
@@ -154,6 +197,15 @@ module Spy
 
     private
 
+    def override_method
+      eval <<-METHOD, binding, __FILE__, __LINE__ + 1
+      __method_spy__ = self
+      lambda do |*__spy_args_#{self.object_id}, &block|
+        __method_spy__.invoke(self, __spy_args_#{self.object_id}, block, caller(1)[0])
+      end
+      METHOD
+    end
+
     def call_with_yield(&block)
       raise "no block sent" unless block
       value = nil
@@ -168,22 +220,36 @@ module Spy
 
     def clear_method!
       @hooked = false
-      @opts = @original_method = @arity_range = @method_visibility = nil
+      @hook_opts = @original_method = @arity_range = @method_visibility = @method_owner= nil
     end
 
     def method_visibility
       @method_visibility ||=
-        if base_object.respond_to?(method_name)
+        if base_object_respond_to?(method_name)
           if original_method && original_method.owner.protected_method_defined?(method_name)
             :protected
           else
             :public
           end
-        elsif base_object.respond_to?(method_name, true)
+        elsif base_object_respond_to?(method_name, true)
           :private
         end
     end
 
+    def base_object_respond_to?(method_name, include_private = false)
+      if @singleton_method
+        base_object.respond_to?(method_name, include_private)
+      else
+        base_object.instance_methods.include?(method_name) || (
+          include_private && base_object.private_instance_methods.include?(method_name)
+        )
+      end
+    end
+
+    def define_method_with
+      @singleton_method ? :define_singleton_method : :define_method
+    end
+
     def check_arity!(arity)
       self.class.check_arity_against_range!(arity_range, arity)
     end
@@ -192,7 +258,16 @@ module Spy
       @arity_range ||= self.class.arity_range_of(original_method) if original_method
     end
 
+    def current_method
+      @singleton_method ? base_object.method(method_name) : base_object.instance_method(method_name)
+    end
+
+    def method_owner
+      @method_owner ||= current_method.owner
+    end
+
     class << self
+      # @private
       def arity_range_of(block)
         raise "#{block.inspect} does not respond to :parameters" unless block.respond_to?(:parameters)
         min = max = 0
@@ -210,6 +285,7 @@ module Spy
         (min..max)
       end
 
+      # @private
       def check_arity_against_range!(arity_range, arity)
         return unless arity_range
         if arity < arity_range.min
@@ -219,21 +295,47 @@ module Spy
         end
       end
 
-      SPY_METHOD_PARAMS = [[:rest, :__spy_args], [:block, :block]]
+      # retrieve the method spy from an object
+      # @param base_object
+      # @param method_name [Symbol]
+      # @param singleton_method [Boolean] this a singleton method or a instance method?
+      # @return [Array<Subroutine>]
+      def get(base_object, method_name, singleton_method = true)
+        if singleton_method
+          if base_object.respond_to?(method_name, true)
+            spied_method = base_object.method(method_name)
+          end
+        elsif (base_object.instance_methods + base_object.private_instance_methods).include?(method_name)
+          spied_method = base_object.instance_method(method_name)
+        end
 
-      def get(base_object, method_name)
-        if (base_object.singleton_methods + base_object.singleton_class.private_instance_methods(false)).include?(method_name.to_sym) && base_object.method(method_name).parameters == SPY_METHOD_PARAMS
-          base_object.send(method_name, SECRET_SPY_KEY)
+        if spied_method
+          Agency.instance.find(get_spy_id(spied_method))
         end
       end
 
+      # retrieve all the spies from a given object
+      # @param base_object
+      # @return [Array<Subroutine>]
       def get_spies(base_object)
-        base_object.singleton_methods.map do |method_name|
-          if base_object.method(method_name).parameters == SPY_METHOD_PARAMS
-            base_object.send(method_name, SECRET_SPY_KEY)
-          end
+        all_methods = base_object.public_methods(false) +
+          base_object.protected_methods(false) +
+          base_object.private_methods(false)
+        all_methods += base_object.instance_methods(false) + base_object.private_instance_methods(false) if base_object.respond_to?(:instance_methods)
+        all_methods.map do |method_name|
+          Agency.instance.find(get_spy_id(base_object.method(method_name)))
         end.compact
       end
+
+      private
+
+      def get_spy_id(method)
+        return nil unless method.parameters[0].is_a?(Array)
+        first_param_name = method.parameters[0][1].to_s
+        if first_param_name.include?("__spy_args")
+          first_param_name.split("_").last.to_i
+        end
+      end
     end
   end
 end

data/lib/spy/version.rb

@@ -1,3 +1,3 @@
 module Spy
-  VERSION = "0.1.0"
+  VERSION = "0.2.1"
 end

data/spec/spy/any_instance_spec.rb

@@ -0,0 +1,518 @@
+require 'spec_helper'
+
+module Spy
+  describe "#any_instance" do
+    class CustomErrorForAnyInstanceSpec < StandardError;end
+
+    let(:klass) do
+      Class.new do
+        def existing_method; :existing_method_return_value; end
+        def existing_method_with_arguments(arg_one, arg_two = nil); :existing_method_with_arguments_return_value; end
+        def another_existing_method; end
+        private
+        def private_method; :private_method_return_value; end
+      end
+    end
+    let(:existing_method_return_value){ :existing_method_return_value }
+
+    context "with #stub" do
+      it "does not suppress an exception when a method that doesn't exist is invoked" do
+        Spy.on_instance_method(klass, :existing_method)
+        expect { klass.new.bar }.to raise_error(NoMethodError)
+      end
+
+      context 'multiple methods' do
+        it "allows multiple methods to be stubbed in a single invocation" do
+          Spy.on_instance_method(klass, :existing_method => 'foo', :another_existing_method => 'bar')
+          instance = klass.new
+          expect(instance.existing_method).to eq('foo')
+          expect(instance.another_existing_method).to eq('bar')
+        end
+      end
+
+      context "behaves as 'every instance'" do
+        it "stubs every instance in the spec" do
+          Subroutine.new(klass, :foo, false).hook(force: true).and_return(result = Object.new)
+          expect(klass.new.foo).to eq(result)
+          expect(klass.new.foo).to eq(result)
+        end
+
+        it "stubs instance created before any_instance was called" do
+          instance = klass.new
+          Spy.on_instance_method(klass, :existing_method).and_return(result = Object.new)
+          expect(instance.existing_method).to eq(result)
+        end
+      end
+
+      context "with #and_return" do
+        it "stubs a method that doesn't exist" do
+          Spy.on_instance_method(klass, :existing_method).and_return(1)
+          expect(klass.new.existing_method).to eq(1)
+        end
+
+        it "stubs a method that exists" do
+          Spy.on_instance_method(klass, :existing_method).and_return(1)
+          expect(klass.new.existing_method).to eq(1)
+        end
+
+        it "returns the same object for calls on different instances" do
+          return_value = Object.new
+          Spy.on_instance_method(klass, :existing_method).and_return(return_value)
+          expect(klass.new.existing_method).to be(return_value)
+          expect(klass.new.existing_method).to be(return_value)
+        end
+      end
+
+      context "with #and_yield" do
+        it "yields the value specified" do
+          yielded_value = Object.new
+          Spy.on_instance_method(klass, :existing_method).and_yield(yielded_value)
+          klass.new.existing_method{|value| expect(value).to be(yielded_value)}
+        end
+      end
+
+      context "with #and_raise" do
+        it "stubs a method that doesn't exist" do
+          Spy.on_instance_method(klass, :existing_method).and_raise(CustomErrorForAnyInstanceSpec)
+          expect { klass.new.existing_method}.to raise_error(CustomErrorForAnyInstanceSpec)
+        end
+
+        it "stubs a method that exists" do
+          Spy.on_instance_method(klass, :existing_method).and_raise(CustomErrorForAnyInstanceSpec)
+          expect { klass.new.existing_method}.to raise_error(CustomErrorForAnyInstanceSpec)
+        end
+      end
+
+      context "with a block" do
+        it "stubs a method" do
+          Spy.on_instance_method(klass, :existing_method) { 1 }
+          expect(klass.new.existing_method).to eq(1)
+        end
+
+        it "returns the same computed value for calls on different instances" do
+          Spy.on_instance_method(klass, :existing_method) { 1 + 2 }
+          expect(klass.new.existing_method).to eq(klass.new.existing_method)
+        end
+      end
+
+      context "core ruby objects" do
+        it "works uniformly across *everything*" do
+          Object.any_instance.stub(:foo).and_return(1)
+          expect(Object.new.foo).to eq(1)
+        end
+
+        it "works with the non-standard constructor []" do
+          Array.any_instance.stub(:foo).and_return(1)
+          expect([].foo).to eq(1)
+        end
+
+        it "works with the non-standard constructor {}" do
+          Hash.any_instance.stub(:foo).and_return(1)
+          expect({}.foo).to eq(1)
+        end
+
+        it "works with the non-standard constructor \"\"" do
+          String.any_instance.stub(:foo).and_return(1)
+          expect("".foo).to eq(1)
+        end
+
+        it "works with the non-standard constructor \'\'" do
+          String.any_instance.stub(:foo).and_return(1)
+          expect(''.foo).to eq(1)
+        end
+
+        it "works with the non-standard constructor module" do
+          Module.any_instance.stub(:foo).and_return(1)
+          module RSpec::SampleRspecTestModule;end
+          expect(RSpec::SampleRspecTestModule.foo).to eq(1)
+        end
+
+        it "works with the non-standard constructor class" do
+          Class.any_instance.stub(:foo).and_return(1)
+          class RSpec::SampleRspecTestClass;end
+          expect(RSpec::SampleRspecTestClass.foo).to eq(1)
+        end
+      end
+    end
+
+    context "unstub implementation" do
+      it "replaces the stubbed method with the original method" do
+        Spy.on_instance_method(klass, :existing_method)
+        klass.any_instance.unstub(:existing_method)
+        expect(klass.new.existing_method).to eq(:existing_method_return_value)
+      end
+
+      it "removes all stubs with the supplied method name" do
+        Spy.on_instance_method(klass, :existing_method).with(1)
+        Spy.on_instance_method(klass, :existing_method).with(2)
+        klass.any_instance.unstub(:existing_method)
+        expect(klass.new.existing_method).to eq(:existing_method_return_value)
+      end
+
+      it "does not remove any expectations with the same method name" do
+        klass.any_instance.should_receive(:existing_method_with_arguments).with(3).and_return(:three)
+        Spy.on_instance_method(klass, :existing_method_with_arguments).with(1)
+        Spy.on_instance_method(klass, :existing_method_with_arguments).with(2)
+        klass.any_instance.unstub(:existing_method_with_arguments)
+        expect(klass.new.existing_method_with_arguments(3)).to eq(:three)
+      end
+
+      it "raises a MockExpectationError if the method has not been stubbed" do
+        expect {
+          klass.any_instance.unstub(:existing_method)
+        }.to raise_error(RSpec::Mocks::MockExpectationError, 'The method `existing_method` was not stubbed or was already unstubbed')
+      end
+    end
+
+    context "with #should_receive" do
+      let(:foo_expectation_error_message) { 'Exactly one instance should have received the following message(s) but didn\'t: foo' }
+      let(:existing_method_expectation_error_message) { 'Exactly one instance should have received the following message(s) but didn\'t: existing_method' }
+
+      context "with an expectation is set on a method which does not exist" do
+        it "returns the expected value" do
+          klass.any_instance.should_receive(:foo).and_return(1)
+          expect(klass.new.foo(1)).to eq(1)
+        end
+
+        it "fails if an instance is created but no invocation occurs" do
+          expect do
+            klass.any_instance.should_receive(:foo)
+            klass.new
+            klass.rspec_verify
+          end.to raise_error(RSpec::Mocks::MockExpectationError, foo_expectation_error_message)
+        end
+
+        it "fails if no instance is created" do
+          expect do
+            klass.any_instance.should_receive(:foo).and_return(1)
+            klass.rspec_verify
+          end.to raise_error(RSpec::Mocks::MockExpectationError, foo_expectation_error_message)
+        end
+
+        it "fails if no instance is created and there are multiple expectations" do
+          expect do
+            klass.any_instance.should_receive(:foo)
+            klass.any_instance.should_receive(:bar)
+            klass.rspec_verify
+          end.to raise_error(RSpec::Mocks::MockExpectationError, 'Exactly one instance should have received the following message(s) but didn\'t: bar, foo')
+        end
+
+        it "allows expectations on instances to take priority" do
+          klass.any_instance.should_receive(:foo)
+          klass.new.foo
+
+          instance = klass.new
+          instance.should_receive(:foo).and_return(result = Object.new)
+          expect(instance.foo).to eq(result)
+        end
+
+        context "behaves as 'exactly one instance'" do
+          it "passes if subsequent invocations do not receive that message" do
+            klass.any_instance.should_receive(:foo)
+            klass.new.foo
+            klass.new
+          end
+
+          it "fails if the method is invoked on a second instance" do
+            instance_one = klass.new
+            instance_two = klass.new
+            expect do
+              klass.any_instance.should_receive(:foo)
+
+              instance_one.foo
+              instance_two.foo
+            end.to raise_error(RSpec::Mocks::MockExpectationError, "The message 'foo' was received by #{instance_two.inspect} but has already been received by #{instance_one.inspect}")
+          end
+        end
+
+        context "normal expectations on the class object" do
+          it "fail when unfulfilled" do
+            expect do
+              klass.any_instance.should_receive(:foo)
+              klass.should_receive(:woot)
+              klass.new.foo
+              klass.rspec_verify
+            end.to(raise_error(RSpec::Mocks::MockExpectationError) do |error|
+              expect(error.message).not_to eq(existing_method_expectation_error_message)
+            end)
+          end
+
+
+          it "pass when expectations are met" do
+            klass.any_instance.should_receive(:foo)
+            klass.should_receive(:woot).and_return(result = Object.new)
+            klass.new.foo
+            expect(klass.woot).to eq(result)
+          end
+        end
+      end
+
+      context "with an expectation is set on a method that exists" do
+        it "returns the expected value" do
+          klass.any_instance.should_receive(:existing_method).and_return(1)
+          expect(klass.new.existing_method(1)).to eq(1)
+        end
+
+        it "fails if an instance is created but no invocation occurs" do
+          expect do
+            klass.any_instance.should_receive(:existing_method)
+            klass.new
+            klass.rspec_verify
+          end.to raise_error(RSpec::Mocks::MockExpectationError, existing_method_expectation_error_message)
+        end
+
+        it "fails if no instance is created" do
+          expect do
+            klass.any_instance.should_receive(:existing_method)
+            klass.rspec_verify
+          end.to raise_error(RSpec::Mocks::MockExpectationError, existing_method_expectation_error_message)
+        end
+
+        it "fails if no instance is created and there are multiple expectations" do
+          expect do
+            klass.any_instance.should_receive(:existing_method)
+            klass.any_instance.should_receive(:another_existing_method)
+            klass.rspec_verify
+          end.to raise_error(RSpec::Mocks::MockExpectationError, 'Exactly one instance should have received the following message(s) but didn\'t: another_existing_method, existing_method')
+        end
+
+        context "after any one instance has received a message" do
+          it "passes if subsequent invocations do not receive that message" do
+            klass.any_instance.should_receive(:existing_method)
+            klass.new.existing_method
+            klass.new
+          end
+
+          it "fails if the method is invoked on a second instance" do
+            instance_one = klass.new
+            instance_two = klass.new
+            expect do
+              klass.any_instance.should_receive(:existing_method)
+
+              instance_one.existing_method
+              instance_two.existing_method
+            end.to raise_error(RSpec::Mocks::MockExpectationError, "The message 'existing_method' was received by #{instance_two.inspect} but has already been received by #{instance_one.inspect}")
+          end
+        end
+      end
+    end
+
+    context "when resetting post-verification" do
+      let(:space) { RSpec::Mocks::Space.new }
+
+      context "existing method" do
+        before(:each) do
+          space.add(klass)
+        end
+
+        context "with stubbing" do
+          context "public methods" do
+            before(:each) do
+              Spy.on_instance_method(klass, :existing_method).and_return(1)
+              expect(klass.method_defined?(:__existing_method_without_any_instance__)).to be_true
+            end
+
+            it "restores the class to its original state after each example when no instance is created" do
+              space.verify_all
+
+              expect(klass.method_defined?(:__existing_method_without_any_instance__)).to be_false
+              expect(klass.new.existing_method).to eq(existing_method_return_value)
+            end
+
+            it "restores the class to its original state after each example when one instance is created" do
+              klass.new.existing_method
+
+              space.verify_all
+
+              expect(klass.method_defined?(:__existing_method_without_any_instance__)).to be_false
+              expect(klass.new.existing_method).to eq(existing_method_return_value)
+            end
+
+            it "restores the class to its original state after each example when more than one instance is created" do
+              klass.new.existing_method
+              klass.new.existing_method
+
+              space.verify_all
+
+              expect(klass.method_defined?(:__existing_method_without_any_instance__)).to be_false
+              expect(klass.new.existing_method).to eq(existing_method_return_value)
+            end
+          end
+
+          context "private methods" do
+            before :each do
+              Spy.on_instance_method(klass, :private_method).and_return(:something)
+              space.verify_all
+            end
+
+            it "cleans up the backed up method" do
+              expect(klass.method_defined?(:__existing_method_without_any_instance__)).to be_false
+            end
+
+            it "restores a stubbed private method after the spec is run" do
+              expect(klass.private_method_defined?(:private_method)).to be_true
+            end
+
+            it "ensures that the restored method behaves as it originally did" do
+              expect(klass.new.send(:private_method)).to eq(:private_method_return_value)
+            end
+          end
+        end
+
+        context "with expectations" do
+          context "private methods" do
+            before :each do
+              klass.any_instance.should_receive(:private_method).and_return(:something)
+              klass.new.private_method
+              space.verify_all
+            end
+
+            it "cleans up the backed up method" do
+              expect(klass.method_defined?(:__existing_method_without_any_instance__)).to be_false
+            end
+
+            it "restores a stubbed private method after the spec is run" do
+              expect(klass.private_method_defined?(:private_method)).to be_true
+            end
+
+            it "ensures that the restored method behaves as it originally did" do
+              expect(klass.new.send(:private_method)).to eq(:private_method_return_value)
+            end
+          end
+
+          context "ensures that the subsequent specs do not see expectations set in previous specs" do
+            context "when the instance created after the expectation is set" do
+              it "first spec" do
+                klass.any_instance.should_receive(:existing_method).and_return(Object.new)
+                klass.new.existing_method
+              end
+
+              it "second spec" do
+                expect(klass.new.existing_method).to eq(existing_method_return_value)
+              end
+            end
+
+            context "when the instance created before the expectation is set" do
+              before :each do
+                @instance = klass.new
+              end
+
+              it "first spec" do
+                klass.any_instance.should_receive(:existing_method).and_return(Object.new)
+                @instance.existing_method
+              end
+
+              it "second spec" do
+                expect(@instance.existing_method).to eq(existing_method_return_value)
+              end
+            end
+          end
+
+          it "ensures that the next spec does not see that expectation" do
+            klass.any_instance.should_receive(:existing_method).and_return(Object.new)
+            klass.new.existing_method
+            space.verify_all
+
+            expect(klass.new.existing_method).to eq(existing_method_return_value)
+          end
+        end
+      end
+
+      context "with multiple calls to any_instance in the same example" do
+        it "does not prevent the change from being rolled back" do
+          Spy.on_instance_method(klass, :existing_method).and_return(false)
+          Spy.on_instance_method(klass, :existing_method).and_return(true)
+
+          klass.rspec_verify
+          expect(klass.new).to respond_to(:existing_method)
+          expect(klass.new.existing_method).to eq(existing_method_return_value)
+        end
+      end
+
+      it "adds an class to the current space when #any_instance is invoked" do
+        klass.any_instance
+        expect(RSpec::Mocks::space.send(:receivers)).to include(klass)
+      end
+
+      it "adds an instance to the current space when stubbed method is invoked" do
+        Spy.on_instance_method(klass, :foo)
+        instance = klass.new
+        instance.foo
+        expect(RSpec::Mocks::space.send(:receivers)).to include(instance)
+      end
+    end
+
+    context 'when used in conjunction with a `dup`' do
+      it "doesn't cause an infinite loop" do
+        Object.any_instance.stub(:some_method)
+        o = Object.new
+        o.some_method
+        expect { o.dup.some_method }.to_not raise_error(SystemStackError)
+      end
+
+      it "doesn't bomb if the object doesn't support `dup`" do
+        klass = Class.new do
+          undef_method :dup
+        end
+        klass.any_instance
+      end
+
+      it "doesn't fail when dup accepts parameters" do
+        klass = Class.new do
+          def dup(funky_option)
+          end
+        end
+
+        klass.any_instance
+
+        expect { klass.new.dup('Dup dup dup') }.to_not raise_error(ArgumentError)
+      end
+    end
+
+    context "when directed at a method defined on a superclass" do
+      let(:sub_klass) { Class.new(klass) }
+
+      it "stubs the method correctly" do
+        Spy.on_instance_method(klass, :existing_method).and_return("foo")
+        expect(sub_klass.new.existing_method).to eq "foo"
+      end
+
+      it "mocks the method correctly" do
+        instance_one = sub_klass.new
+        instance_two = sub_klass.new
+        expect do
+          klass.any_instance.should_receive(:existing_method)
+          instance_one.existing_method
+          instance_two.existing_method
+        end.to raise_error(RSpec::Mocks::MockExpectationError, "The message 'existing_method' was received by #{instance_two.inspect} but has already been received by #{instance_one.inspect}")
+      end
+    end
+
+    context "when a class overrides Object#method" do
+      let(:http_request_class) { Struct.new(:method, :uri) }
+
+      it "stubs the method correctly" do
+        http_request_class.any_instance.stub(:existing_method).and_return("foo")
+        expect(http_request_class.new.existing_method).to eq "foo"
+      end
+
+      it "mocks the method correctly" do
+        http_request_class.any_instance.should_receive(:existing_method).and_return("foo")
+        expect(http_request_class.new.existing_method).to eq "foo"
+      end
+    end
+
+    context "when used after the test has finished" do
+      it "restores the original behavior of a stubbed method" do
+        Spy.on_instance_method(klass, :existing_method).and_return(:stubbed_return_value)
+
+        instance = klass.new
+        expect(instance.existing_method).to eq :stubbed_return_value
+
+        RSpec::Mocks.verify
+
+        expect(instance.existing_method).to eq :existing_method_return_value
+      end
+    end
+  end
+end