rr 0.10.2 → 0.10.4

data/lib/rr/method_dispatches/base_method_dispatch.rb

@@ -0,0 +1,84 @@
+module RR
+  module MethodDispatches
+    class BaseMethodDispatch
+      extend Forwardable
+      include Space::Reader
+
+      attr_reader :args, :block, :double
+
+      def call
+        raise NotImplementedError
+      end
+
+      protected
+      def find_double_to_attempt
+        matches = DoubleMatches.new(doubles).find_all_matches(args)
+
+        unless matches.exact_terminal_doubles_to_attempt.empty?
+          return matches.exact_terminal_doubles_to_attempt.first
+        end
+
+        unless matches.exact_non_terminal_doubles_to_attempt.empty?
+          return matches.exact_non_terminal_doubles_to_attempt.last
+        end
+
+        unless matches.wildcard_terminal_doubles_to_attempt.empty?
+          return matches.wildcard_terminal_doubles_to_attempt.first
+        end
+
+        unless matches.wildcard_non_terminal_doubles_to_attempt.empty?
+          return matches.wildcard_non_terminal_doubles_to_attempt.last
+        end
+
+        unless matches.matching_doubles.empty?
+          return matches.matching_doubles.first # This will raise a TimesCalledError
+        end
+
+        return nil
+      end
+
+      def call_yields
+        if definition.yields_value
+          if block
+            block.call(*definition.yields_value)
+          else
+            raise ArgumentError, "A Block must be passed into the method call when using yields"
+          end
+        end
+      end
+
+      def call_original_method_missing
+        subject.__send__(original_method_missing_alias_name, method_name, *args, &block)
+      end
+
+      def implementation_is_original_method?
+        double.implementation_is_original_method?
+      end
+
+      def extract_subject_from_return_value(return_value)
+        case return_value
+          when DoubleDefinitions::DoubleDefinition
+            return_value.root_subject
+          when DoubleDefinitions::DoubleDefinitionCreatorProxy
+            return_value.__creator__.root_subject
+          else
+            return_value
+        end
+      end
+
+      def double_not_found_error
+        message =
+          "On subject #{subject},\n" <<
+          "unexpected method invocation:\n" <<
+          "  #{Double.formatted_name(method_name, args)}\n" <<
+          "expected invocations:\n" <<
+          Double.list_message_part(doubles)
+        raise Errors::DoubleNotFoundError, message
+      end
+
+      def_delegators :definition, :after_call_proc
+      def_delegators :double, :definition
+      def_delegators :double_injection, :doubles
+    end
+  end
+end

data/lib/rr/method_dispatches/method_dispatch.rb

@@ -0,0 +1,58 @@
+module RR
+  module MethodDispatches
+    class MethodDispatch < BaseMethodDispatch
+      attr_reader :double_injection
+      def initialize(double_injection, args, block)
+        @double_injection, @args, @block = double_injection, args, block
+        @double = find_double_to_attempt
+      end
+
+      def call
+        space.record_call(subject, method_name, args, block)
+        if double
+          double.method_call(args)
+          call_yields
+          return_value = extract_subject_from_return_value(call_implementation)
+          if after_call_proc
+            extract_subject_from_return_value(after_call_proc.call(return_value))
+          else
+            return_value
+          end
+        else
+          double_not_found_error
+        end
+      end
+
+      def call_original_method
+        if subject_has_original_method?
+          subject.__send__(original_method_alias_name, *args, &block)
+        elsif subject_has_original_method_missing?
+          call_original_method_missing
+        else
+          subject.__send__(:method_missing, method_name, *args, &block)
+        end
+      end
+
+      protected
+      def call_implementation
+        if implementation_is_original_method?
+          call_original_method
+        else
+          if implementation
+            if implementation.is_a?(Method)
+              implementation.call(*args, &block)
+            else
+              call_args = block ? args + [ProcFromBlock.new(&block)] : args
+              implementation.call(*call_args)
+            end
+          else
+            nil
+          end
+        end
+      end
+
+      def_delegators :definition, :implementation
+      def_delegators :double_injection, :subject_has_original_method?, :subject_has_original_method_missing?, :subject, :method_name, :original_method_alias_name
+    end
+  end
+end

data/lib/rr/method_dispatches/method_missing_dispatch.rb

@@ -0,0 +1,59 @@
+module RR
+  module MethodDispatches
+    class MethodMissingDispatch < BaseMethodDispatch
+      class << self
+        def original_method_missing_alias_name
+          "__rr__original_method_missing"
+        end
+      end
+
+      attr_reader :subject, :method_name
+      def initialize(subject, method_name, args, block)
+        @subject, @method_name, @args, @block = subject, method_name, args, block
+      end
+
+      def call
+        if space.double_injection_exists?(subject, method_name)
+          space.record_call(subject, method_name, args, block)
+          @double = find_double_to_attempt
+
+          if double
+            double.method_call(args)
+            call_yields
+            return_value = extract_subject_from_return_value(call_implementation)
+            if after_call_proc
+              extract_subject_from_return_value(after_call_proc.call(return_value))
+            else
+              return_value
+            end
+          else
+            double_not_found_error
+          end
+        else
+          call_original_method
+        end
+      end
+
+      def call_original_method
+        double_injection.bypass_bound_method do
+          call_original_method_missing
+        end
+      end
+
+      protected
+      def call_implementation
+        if implementation_is_original_method?
+          call_original_method
+        else
+          nil
+        end
+      end
+
+      def double_injection
+        space.double_injection(subject, method_name)
+      end
+
+      def_delegators 'self.class', :original_method_missing_alias_name
+    end
+  end
+end

data/lib/rr/space.rb

@@ -19,10 +19,14 @@ module RR
       end
     end
 
-    attr_reader :double_injections, :ordered_doubles, :recorded_calls
+    attr_reader :double_injections, :method_missing_injections, :ordered_doubles, :recorded_calls
     attr_accessor :trim_backtrace
     def initialize
-      @double_injections = HashWithObjectIdKey.new
+      @double_injections = HashWithObjectIdKey.new do |hash, subject_object|
+        hash.set_with_object_id(subject_object, {})
+      end
+      @method_missing_injections = HashWithObjectIdKey.new
+      @singleton_method_added_injections = HashWithObjectIdKey.new
       @ordered_doubles = []
       @trim_backtrace = false
       @recorded_calls = RR::RecordedCalls.new
@@ -34,7 +38,7 @@ module RR
     # subject.
     def double_injection(subject, method_name)
       @double_injections[subject][method_name.to_sym] ||= begin
-        DoubleInjection.new(subject, method_name.to_sym, (class << subject; self; end)).bind
+        Injections::DoubleInjection.new(subject, method_name.to_sym, (class << subject; self; end)).bind
       end
     end
 
@@ -42,6 +46,26 @@ module RR
       @double_injections.include?(subject) && @double_injections[subject].include?(method_name.to_sym)
     end
 
+    def method_missing_injection(subject)
+      @method_missing_injections[subject] ||= begin
+        Injections::MethodMissingInjection.new(subject).bind
+      end
+    end
+
+    def method_missing_injection_exists?(subject)
+      @method_missing_injections.include?(subject)
+    end
+
+    def singleton_method_added_injection(subject)
+      @singleton_method_added_injections[subject] ||= begin
+        Injections::SingletonMethodAddedInjection.new(subject).bind
+      end
+    end
+
+    def singleton_method_added_injection_exists?(subject)
+      @singleton_method_added_injections.include?(subject)
+    end
+
     # Registers the ordered Double to be verified.
     def register_ordered_double(double)
       @ordered_doubles << double unless ordered_doubles.include?(double)
@@ -80,6 +104,8 @@ module RR
     def reset
       reset_ordered_doubles
       reset_double_injections
+      reset_method_missing_injections
+      reset_singleton_method_added_injections
       reset_recorded_calls
     end
 
@@ -114,7 +140,21 @@ module RR
           reset_double(subject, method_name)
         end
       end
-    end  
+    end
+
+    def reset_method_missing_injections
+      @method_missing_injections.each do |subject, injection|
+        injection.reset
+      end
+      @method_missing_injections.clear
+    end
+
+    def reset_singleton_method_added_injections
+      @singleton_method_added_injections.each do |subject, injection|
+        injection.reset
+      end
+      @singleton_method_added_injections.clear
+    end
     
     def reset_recorded_calls
       @recorded_calls.clear

data/lib/rr/spy_verification_proxy.rb

@@ -1,7 +1,7 @@
 module RR
   class SpyVerificationProxy
     instance_methods.each do |m|
-      unless m =~ /^_/ || m.to_s == 'object_id' || m.to_s == "instance_eval" || m.to_s == 'respond_to?'
+      unless m =~ /^_/ || m.to_s == 'object_id' || m.to_s == "instance_eval" || m.to_s == "instance_exec" || m.to_s == 'respond_to?'
         alias_method "__blank_slated_#{m}", m
         undef_method m
       end

data/spec/rr/double_injection/double_injection_spec.rb

@@ -1,95 +1,552 @@
 require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
 
 module RR
-  describe DoubleInjection do
-    attr_reader :subject, :method_name, :double_injection
-    macro("sets up object and method_name") do
-      it "sets up object and method_name" do
-        double_injection.subject.should === subject
-        double_injection.method_name.should == method_name.to_sym
+  module Injections
+    describe DoubleInjection do
+      attr_reader :subject, :method_name, :double_injection
+      macro("sets up subject and method_name") do
+        it "sets up subject and method_name" do
+          double_injection.subject.should === subject
+          double_injection.method_name.should == method_name.to_sym
+        end
       end
-    end
 
-    describe "#initialize" do
-      context "when method_name is a symbol" do
-        send("sets up object and method_name")
+      describe "mock/stub" do
+        context "when the subject responds to the injected method" do
+          before do
+            @subject = Object.new
+            class << subject
+              attr_reader :original_foobar_called
 
-        before do
-          @subject = Object.new
-          @method_name = :foobar
-          subject.methods.should_not include(method_name.to_s)
-          @double_injection = DoubleInjection.new(subject, method_name, (class << subject; self; end))
-        end
-      end
+              def foobar
+                @original_foobar_called = true
+                :original_foobar
+              end
+            end
 
-      context "when method_name is a string" do
-        before do
-          @subject = Object.new
-          @method_name = 'foobar'
-          subject.methods.should_not include(method_name)
-          @double_injection = DoubleInjection.new(subject, method_name, (class << subject; self; end))
-        end
+            def subject.foobar
+              :original_foobar
+            end
 
-        send("sets up object and method_name")
-      end
+            subject.should respond_to(:foobar)
+            subject.methods.should include('foobar')
+            stub(subject).foobar {:new_foobar}
+          end
+
+          describe "being bound" do
+            it "sets __rr__original_{method_name} to the original method" do
+              subject.__rr__original_foobar.should == :original_foobar
+            end
+
+            describe "being called" do
+              it "returns the return value of the block" do
+                subject.foobar.should == :new_foobar
+              end
+
+              it "does not call the original method" do
+                subject.foobar
+                subject.original_foobar_called.should be_nil
+              end
+            end
 
-      context "when method does not exist on object" do
-        before do
-          @subject = Object.new
-          @method_name = :foobar
-          subject.methods.should_not include(method_name.to_s)
+            describe "being reset" do
+              before do
+                RR::Space.reset_double(subject, :foobar)
+              end
+
+              it "rebinds the original method" do
+                subject.foobar.should == :original_foobar
+              end
+
+              it "removes __rr__original_{method_name}" do
+                subject.should_not respond_to(:__rr__original_foobar)
+              end
+            end
+          end
         end
 
-        context "when the subject descends from active record" do
+        context "when the subject does not respond to the injected method" do
           before do
-            def subject.descends_from_active_record?
-              true
+            @subject = Object.new
+            subject.should_not respond_to(:foobar)
+            subject.methods.should_not include('foobar')
+            stub(subject).foobar {:new_foobar}
+          end
+
+          it "does not set __rr__original_{method_name} to the original method" do
+            subject.should_not respond_to(:__rr__original_foobar)
+          end
+
+          describe "being called" do
+            it "calls the newly defined method" do
+              subject.foobar.should == :new_foobar
             end
-            def subject.respond_to?(name)
-              return true if name == :foobar
-              super
+          end
+
+          describe "being reset" do
+            before do
+              RR::Space.reset_double(subject, :foobar)
             end
-            def subject.method_missing(name, *args, &block)
-              if name == :foobar
-                def self.foobar
-                end
-              else
-                super
-              end
+
+            it "unsets the foobar method" do
+              subject.should_not respond_to(:foobar)
+              subject.methods.should_not include('foobar')
             end
-            @double_injection = DoubleInjection.new(subject, method_name, (class << subject; self; end))
           end
-          
-          send("sets up object and method_name")
+        end
 
-          example "object has the original method" do
-            double_injection.object_has_original_method?.should be_true
+        context "when the subject redefines respond_to?" do
+          it "does not try to call the implementation" do
+            class << subject
+              def respond_to?(method_symbol, include_private = false)
+                method_symbol == :foobar
+              end
+            end
+            mock(@subject).foobar
+            @subject.foobar.should == nil
           end
         end
       end
 
-      context "when method exists on object" do
-        send("sets up object and method_name")
+      describe "mock/stub + proxy" do
+        context "when the subject responds to the injected method" do
+          context "when the subject has the method defined" do
+            describe "being bound" do
+              before do
+                @subject = Object.new
 
-        before do
-          @subject = Object.new
-          @method_name = :to_s
-          subject.methods.should include(method_name.to_s)
-          @double_injection = DoubleInjection.new(subject, method_name, (class << subject; self; end))
-        end
+                def subject.foobar
+                  :original_foobar
+                end
+
+                subject.should respond_to(:foobar)
+                subject.methods.should include('foobar')
+                stub.proxy(subject).foobar {:new_foobar}
+              end
+
+              it "aliases the original method to __rr__original_{method_name}" do
+                subject.__rr__original_foobar.should == :original_foobar
+              end
+
+              it "replaces the original method with the new method" do
+                subject.foobar.should == :new_foobar
+              end
+
+              describe "being called" do
+                it "calls the original method first and sends it into the block" do
+                  original_return_value = nil
+                  stub.proxy(subject).foobar {|original_return_value| :new_foobar}
+                  subject.foobar.should == :new_foobar
+                  original_return_value.should == :original_foobar
+                end
+              end
+
+              describe "being reset" do
+                before do
+                  RR::Space.reset_double(subject, :foobar)
+                end
+
+                it "rebinds the original method" do
+                  subject.foobar.should == :original_foobar
+                end
+
+                it "removes __rr__original_{method_name}" do
+                  subject.should_not respond_to(:__rr__original_foobar)
+                end
+              end
+            end
+          end
+
+          context "when the subject does not have the method defined" do
+            describe "being bound" do
+              context "when the subject has not been previously bound to" do
+                before do
+                  @subject = Object.new
+                  setup_subject
+
+                  subject.should respond_to(:foobar)
+                  stub.proxy(subject).foobar {:new_foobar}
+                end
+
+                def setup_subject
+                  def subject.respond_to?(method_name)
+                    if method_name.to_sym == :foobar
+                      true
+                    else
+                      super
+                    end
+                  end
+                end
+
+                it "does not define __rr__original_{method_name}" do
+                  subject.methods.should_not include("__rr__original_foobar")
+                end
+
+                context "when method is defined after being bound and before being called" do
+                  def setup_subject
+                    super
+                    def subject.foobar
+                      :original_foobar
+                    end
+                  end
+
+                  describe "being called" do
+                    it "defines __rr__original_{method_name} to be the lazily created method" do
+                      subject.methods.should include("__rr__original_foobar")
+                      subject.__rr__original_foobar.should == :original_foobar
+                    end
+
+                    it "calls the original method first and sends it into the block" do
+                      original_return_value = nil
+                      stub.proxy(subject).foobar {|original_return_value| :new_foobar}
+                      subject.foobar.should == :new_foobar
+                      original_return_value.should == :original_foobar
+                    end
+                  end
+
+                  describe "being reset" do
+                    before do
+                      RR::Space.reset_double(subject, :foobar)
+                    end
+
+                    it "rebinds the original method" do
+                      subject.foobar.should == :original_foobar
+                    end
+
+                    it "removes __rr__original_{method_name}" do
+                      subject.should_not respond_to(:__rr__original_foobar)
+                    end
+                  end
+                end
+
+                context "when method is still not defined" do
+                  context "when the method is lazily created" do
+                    def setup_subject
+                      super
+                      def subject.method_missing(method_name, *args, &block)
+                        if method_name.to_sym == :foobar
+                          def self.foobar
+                            :original_foobar
+                          end
 
-        it "has a original_method" do
-          double_injection.object_has_original_method?.should be_true
+                          foobar
+                        else
+                          super
+                        end
+                      end
+                    end
+
+                    describe "being called" do
+                      it "defines __rr__original_{method_name} to be the lazily created method" do
+                        subject.foobar
+                        subject.methods.should include("__rr__original_foobar")
+                        subject.__rr__original_foobar.should == :original_foobar
+                      end
+
+                      it "calls the lazily created method and returns the injected method return value" do
+                        original_return_value = nil
+                        stub.proxy(subject).foobar {|original_return_value| :new_foobar}
+                        subject.foobar.should == :new_foobar
+                        original_return_value.should == :original_foobar
+                      end
+                    end
+
+                    describe "being reset" do
+                      context "when reset before being called" do
+                        before do
+                          RR::Space.reset_double(subject, :foobar)
+                        end
+
+                        it "rebinds the original method" do
+                          subject.foobar.should == :original_foobar
+                        end
+
+                        it "removes __rr__original_{method_name}" do
+                          subject.should_not respond_to(:__rr__original_foobar)
+                        end
+                      end
+                    end
+                  end
+
+                  context "when the method is not lazily created (handled in method_missing)" do
+                    def setup_subject
+                      super
+                      def subject.method_missing(method_name, *args, &block)
+                        if method_name.to_sym == :foobar
+                          :original_foobar
+                        else
+                          super
+                        end
+                      end
+                    end
+
+                    describe "being called" do
+                      it "does not define the __rr__original_{method_name}" do
+                        subject.foobar
+                        subject.methods.should_not include("__rr__original_foobar")
+                      end
+
+                      it "calls the lazily created method and returns the injected method return value" do
+                        original_return_value = nil
+                        stub.proxy(subject).foobar {|original_return_value| :new_foobar}
+                        subject.foobar.should == :new_foobar
+                        original_return_value.should == :original_foobar
+                      end
+                    end
+
+                    describe "being reset" do
+                      before do
+                        RR::Space.reset_double(subject, :foobar)
+                      end
+
+                      it "rebinds the original method" do
+                        subject.foobar.should == :original_foobar
+                      end
+
+                      it "removes __rr__original_{method_name}" do
+                        subject.should_not respond_to(:__rr__original_foobar)
+                      end
+                    end
+                  end
+                end
+              end
+
+              context "when the subject has been previously bound to" do
+                before do
+                  @subject = Object.new
+                  setup_subject
+
+                  subject.should respond_to(:foobar)
+                  stub.proxy(subject).baz {:new_baz}
+                  stub.proxy(subject).foobar {:new_foobar}
+                end
+
+                def setup_subject
+                  def subject.respond_to?(method_name)
+                    if method_name.to_sym == :foobar || method_name.to_sym == :baz
+                      true
+                    else
+                      super
+                    end
+                  end
+                end
+
+                it "does not define __rr__original_{method_name}" do
+                  subject.methods.should_not include("__rr__original_foobar")
+                end
+
+                context "when method is defined after being bound and before being called" do
+                  def setup_subject
+                    super
+                    def subject.foobar
+                      :original_foobar
+                    end
+                  end
+
+                  describe "being called" do
+                    it "defines __rr__original_{method_name} to be the lazily created method" do
+                      subject.methods.should include("__rr__original_foobar")
+                      subject.__rr__original_foobar.should == :original_foobar
+                    end
+
+                    it "calls the original method first and sends it into the block" do
+                      original_return_value = nil
+                      stub.proxy(subject).foobar {|original_return_value| :new_foobar}
+                      subject.foobar.should == :new_foobar
+                      original_return_value.should == :original_foobar
+                    end
+                  end
+
+                  describe "being reset" do
+                    before do
+                      RR::Space.reset_double(subject, :foobar)
+                    end
+
+                    it "rebinds the original method" do
+                      subject.foobar.should == :original_foobar
+                    end
+
+                    it "removes __rr__original_{method_name}" do
+                      subject.should_not respond_to(:__rr__original_foobar)
+                    end
+                  end
+                end
+
+                context "when method is still not defined" do
+                  context "when the method is lazily created" do
+                    def setup_subject
+                      super
+                      def subject.method_missing(method_name, *args, &block)
+                        if method_name.to_sym == :foobar
+                          def self.foobar
+                            :original_foobar
+                          end
+
+                          foobar
+                        else
+                          super
+                        end
+                      end
+                    end
+
+                    describe "being called" do
+                      it "defines __rr__original_{method_name} to be the lazily created method" do
+                        subject.foobar
+                        subject.methods.should include("__rr__original_foobar")
+                        subject.__rr__original_foobar.should == :original_foobar
+                      end
+
+                      it "calls the lazily created method and returns the injected method return value" do
+                        original_return_value = nil
+                        stub.proxy(subject).foobar {|original_return_value| :new_foobar}
+                        subject.foobar.should == :new_foobar
+                        original_return_value.should == :original_foobar
+                      end
+                    end
+
+                    describe "being reset" do
+                      context "when reset before being called" do
+                        before do
+                          RR::Space.reset_double(subject, :foobar)
+                        end
+
+                        it "rebinds the original method" do
+                          subject.foobar.should == :original_foobar
+                        end
+
+                        it "removes __rr__original_{method_name}" do
+                          subject.should_not respond_to(:__rr__original_foobar)
+                        end
+                      end
+                    end
+                  end
+
+                  context "when the method is not lazily created (handled in method_missing)" do
+                    def setup_subject
+                      super
+                      def subject.method_missing(method_name, *args, &block)
+                        if method_name.to_sym == :foobar
+                          :original_foobar
+                        else
+                          super
+                        end
+                      end
+                    end
+
+                    describe "being called" do
+                      it "does not define the __rr__original_{method_name}" do
+                        subject.foobar
+                        subject.methods.should_not include("__rr__original_foobar")
+                      end
+
+                      it "calls the lazily created method and returns the injected method return value" do
+                        original_return_value = nil
+                        stub.proxy(subject).foobar {|original_return_value| :new_foobar}
+                        subject.foobar.should == :new_foobar
+                        original_return_value.should == :original_foobar
+                      end
+                    end
+
+                    describe "being reset" do
+                      before do
+                        RR::Space.reset_double(subject, :foobar)
+                      end
+
+                      it "rebinds the original method" do
+                        subject.foobar.should == :original_foobar
+                      end
+
+                      it "removes __rr__original_{method_name}" do
+                        subject.should_not respond_to(:__rr__original_foobar)
+                      end
+                    end
+                  end
+                end
+              end
+            end
+          end
         end
-      end
 
-      context "when method_name is ==" do
-        send("sets up object and method_name")
+        context "when the subject does not respond to the injected method" do
+          context "when the subject responds to the method via method_missing" do
+            describe "being bound" do
+              before do
+                @subject = Object.new
+                subject.should_not respond_to(:foobar)
+                subject.methods.should_not include('foobar')
+                class << subject
+                  def method_missing(method_name, *args, &block)
+                    if method_name == :foobar
+                      :original_foobar
+                    else
+                      super
+                    end
+                  end
+                end
+                stub.proxy(subject).foobar {:new_foobar}
+              end
+
+              it "adds the method to the subject" do
+                subject.should respond_to(:foobar)
+                subject.methods.should include('foobar')
+              end
+
+              describe "being called" do
+                it "calls the original method first and sends it into the block" do
+                  original_return_value = nil
+                  stub.proxy(subject).foobar {|original_return_value| :new_foobar}
+                  subject.foobar.should == :new_foobar
+                  original_return_value.should == :original_foobar
+                end
+              end
+
+              describe "being reset" do
+                before do
+                  RR::Space.reset_double(subject, :foobar)
+                end
+
+                it "unsets the foobar method" do
+                  subject.should_not respond_to(:foobar)
+                  subject.methods.should_not include('foobar')
+                end
+              end
+            end
+          end
+
+          context "when the subject would raise a NoMethodError when the method is called" do
+            describe "being bound" do
+              before do
+                @subject = Object.new
+                subject.should_not respond_to(:foobar)
+                subject.methods.should_not include('foobar')
+                stub.proxy(subject).foobar {:new_foobar}
+              end
+
+              it "adds the method to the subject" do
+                subject.should respond_to(:foobar)
+                subject.methods.should include('foobar')
+              end
+
+              describe "being called" do
+                it "raises a NoMethodError" do
+                  lambda do
+                    subject.foobar
+                  end.should raise_error(NoMethodError)
+                end
+              end
+
+              describe "being reset" do
+                before do
+                  RR::Space.reset_double(subject, :foobar)
+                end
 
-        before do
-          @subject = Object.new
-          @method_name = '=='
-          @double_injection = DoubleInjection.new(subject, method_name, (class << subject; self; end))
+                it "unsets the foobar method" do
+                  subject.should_not respond_to(:foobar)
+                  subject.methods.should_not include('foobar')
+                end
+              end
+            end
+          end
         end
       end
     end