rr 1.0.4 → 1.0.5.rc1

data/spec/rr/rspec/rspec_adapter_spec.rb

@@ -1,63 +0,0 @@
-require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
-
-module RR
-  module Adapters
-    describe Rspec do
-      attr_reader :fixture, :subject, :method_name
-      describe "#setup_mocks_for_rspec" do
-        before do
-          @fixture = Object.new
-          fixture.extend Rspec
-
-          @subject = Object.new
-          @method_name = :foobar
-        end
-
-        it "resets the double_injections" do
-          stub(subject).foobar
-          ::RR::Injections::DoubleInjection.instances.should_not be_empty
-
-          fixture.setup_mocks_for_rspec
-          ::RR::Injections::DoubleInjection.instances.should be_empty
-        end
-      end
-
-      describe "#verify_mocks_for_rspec" do
-        before do
-          @fixture = Object.new
-          fixture.extend Rspec
-
-          @subject = Object.new
-          @method_name = :foobar
-        end
-
-        it "verifies the double_injections" do
-          mock(subject).foobar
-
-          lambda do
-            fixture.verify_mocks_for_rspec
-          end.should raise_error(::RR::Errors::TimesCalledError)
-          ::RR::Injections::DoubleInjection.instances.should be_empty
-        end
-      end
-
-      describe "#teardown_mocks_for_rspec" do
-        before do
-          @fixture = Object.new
-          fixture.extend Rspec
-
-          @subject = Object.new
-          @method_name = :foobar
-        end
-
-        it "resets the double_injections" do
-          stub(subject).foobar
-          ::RR::Injections::DoubleInjection.instances.should_not be_empty
-
-          fixture.teardown_mocks_for_rspec
-          ::RR::Injections::DoubleInjection.instances.should be_empty
-        end
-      end
-    end
-  end
-end

data/spec/rr/rspec/rspec_backtrace_tweaking_spec.rb

@@ -1,31 +0,0 @@
-require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
-
-module RR
-  module Adapters
-    describe Rspec do
-      describe "#trim_backtrace" do
-        it "does not set trim_backtrace" do
-          RR.trim_backtrace.should == false
-        end
-      end
-
-      describe ".included" do
-        it "does not add backtrace identifier twice" do
-          length = ::Spec::Runner::QuietBacktraceTweaker::IGNORE_PATTERNS.length
-          class << Object.new
-            include ::RR::Adapters::Rspec
-          end
-          ::Spec::Runner::QuietBacktraceTweaker::IGNORE_PATTERNS.length.should == length
-        end
-      end
-
-      describe "backtrace tweaking" do
-        it "hides rr library from the backtrace by default" do
-          dir = File.dirname(__FILE__)
-          output = `ruby #{dir}/rspec_backtrace_tweaking_spec_fixture.rb`
-          output.should_not include("lib/rr")
-        end
-      end
-    end
-  end
-end

data/spec/rr/rspec/rspec_backtrace_tweaking_spec_fixture.rb

@@ -1,11 +0,0 @@
-require 'rubygems'
-require "spec"
-dir = File.dirname(__FILE__)
-require File.expand_path("#{dir}/../../../lib/rr")
-
-describe "Example" do
-  it("hides RR framework in backtrace") do
-    mock(subject).foobar()
-    RR.verify_double(subject, :foobar)
-  end
-end

data/spec/rr/rspec/rspec_usage_spec.rb

@@ -1,86 +0,0 @@
-require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
-
-describe RR do
-  attr_reader :subject
-  before do
-    @subject = Object.new
-  end
-
-  describe "#mock" do
-    it "creates a mock DoubleInjection Double" do
-      mock(subject).foobar(1, 2) {:baz}
-      subject.foobar(1, 2).should == :baz
-    end
-  end
-
-  describe "#stub" do
-    it "creates a stub DoubleInjection Double" do
-      stub(subject).foobar {:baz}
-      subject.foobar("any", "thing").should == :baz
-    end
-  end
-
-  describe "#mock and #proxy" do
-    before do
-      def subject.foobar
-        :baz
-      end
-    end
-
-    it "creates a proxy DoubleInjection Double" do
-      mock.proxy(subject).foobar
-      subject.foobar.should == :baz
-    end
-  end
-
-  describe "#stub and #proxy" do
-    before do
-      def subject.foobar
-        :baz
-      end
-    end
-
-    it "creates a proxy DoubleInjection Double" do
-      stub.proxy(subject).foobar
-      subject.foobar.should == :baz
-    end
-  end
-
-  describe "#stub and #proxy" do
-    before do
-      def subject.foobar
-        :baz
-      end
-    end
-
-    it "creates a proxy DoubleInjection Double" do
-      stub.proxy(subject).foobar
-      subject.foobar.should == :baz
-    end
-  end
-
-  describe "spies" do
-    it "validates that a Double was called after it was called" do
-      stub(subject).foobar
-      subject.foobar(1, 2)
-
-      subject.should have_received.foobar(1, 2)
-      lambda do
-        subject.should have_received.foobar(1, 2, 3)
-      end.should raise_error(Spec::Expectations::ExpectationNotMetError)
-    end
-  end
-
-  it "creates an invocation matcher with a method name" do
-    method  = :test
-    matcher = 'fake'
-    mock(RR::Adapters::Rspec::InvocationMatcher).new(method) { matcher }
-    have_received(method).should == matcher
-  end
-
-  it "creates an invocation matcher without a method name" do
-    matcher = 'fake'
-    mock(RR::Adapters::Rspec::InvocationMatcher).new(nil) { matcher }
-    have_received.should == matcher
-  end
-end

data/spec/rr/space/hash_with_object_id_key_spec.rb

@@ -1,88 +0,0 @@
-require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
-
-module RR
-  describe HashWithObjectIdKey do
-    describe "#[] and #[]=" do
-      it "stores object via object id" do
-        hash = HashWithObjectIdKey.new
-        array_1 = []
-        hash[array_1] = 1
-        array_2 = []
-        hash[array_2] = 2
-
-        hash[array_1].should_not == hash[array_2]
-      end
-
-      it "stores the passed in object" do
-        hash = HashWithObjectIdKey.new
-        obj = Object.new
-        hash[obj] = 1
-        hash.instance_eval {@keys}.should == {obj.__id__ => obj}
-      end
-    end
-
-    describe "#each" do
-      it "iterates through the items in the hash" do
-        hash = HashWithObjectIdKey.new
-        hash['one'] = 1
-        hash['two'] = 2
-
-        keys = []
-        values = []
-        hash.each do |key, value|
-          keys << key
-          values << value
-        end
-
-        keys.sort.should == ['one', 'two']
-        values.sort.should == [1, 2]
-      end
-    end
-
-    describe "#delete" do
-      before do
-        @hash = HashWithObjectIdKey.new
-        @key = Object.new
-        @hash[@key] = 1
-      end
-
-      it "removes the object from the hash" do
-        @hash.delete(@key)
-        @hash[@key].should be_nil
-      end
-
-      it "removes the object from the keys hash" do
-        @hash.delete(@key)
-        @hash.instance_eval {@keys}.should == {}
-      end
-    end
-
-    describe "#keys" do
-      before do
-        @hash = HashWithObjectIdKey.new
-        @key = Object.new
-        @hash[@key] = 1
-      end
-
-      it "returns an array of the keys" do
-        @hash.keys.should == [@key]
-      end
-    end
-
-    describe "#include?" do
-      before do
-        @hash = HashWithObjectIdKey.new
-        @key = Object.new
-        @hash[@key] = 1
-      end
-
-      it "returns true when the key is in the Hash" do
-        @hash.include?(@key).should be_true
-      end
-
-      it "returns false when the key is not in the Hash" do
-        @hash.include?(Object.new).should be_false
-      end
-    end
-  end
-end

data/spec/rr/space/space_spec.rb

@@ -1,596 +0,0 @@
-require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
-
-module RR
-  describe Space do
-    it_should_behave_like "Swapped Space"
-    attr_reader :subject, :method_name, :double_injection
-
-    before do
-      @subject = Object.new
-    end
-
-    describe "#record_call" do
-      it "should add a call to the list" do
-        object = Object.new
-        block = lambda {}
-        space.record_call(object, :to_s, [], block)
-        space.recorded_calls.should == RR::RecordedCalls.new([[object, :to_s, [], block]])
-      end
-    end
-
-    describe "#double_injection" do
-      context "when existing subject == but not === with the same method name" do
-        it "creates a new DoubleInjection" do
-          subject_1 = []
-          subject_2 = []
-          (subject_1 === subject_2).should be_true
-          subject_1.__id__.should_not == subject_2.__id__
-
-          injection_1 = Injections::DoubleInjection.find_or_create_by_subject(subject_1, :foobar)
-          injection_2 = Injections::DoubleInjection.find_or_create_by_subject(subject_2, :foobar)
-
-          injection_1.should_not == injection_2
-        end
-      end
-
-      context "when a DoubleInjection is not registered for the subject and method_name" do
-        before do
-          def subject.foobar(*args)
-            :original_foobar
-          end
-
-          @method_name = :foobar
-        end
-
-        context "when method_name is a symbol" do
-          it "returns double_injection and adds double_injection to double_injection list" do
-            double_injection = Injections::DoubleInjection.find_or_create_by_subject(subject, method_name)
-            Injections::DoubleInjection.find_or_create_by_subject(subject, method_name).should === double_injection
-            double_injection.subject_class.should == (class << subject; self; end)
-            double_injection.method_name.should === method_name
-          end
-        end
-
-        context "when method_name is a string" do
-          it "returns double_injection and adds double_injection to double_injection list" do
-            double_injection = Injections::DoubleInjection.find_or_create_by_subject(subject, 'foobar')
-            Injections::DoubleInjection.find_or_create_by_subject(subject, method_name).should === double_injection
-            double_injection.subject_class.should == (class << subject; self; end)
-            double_injection.method_name.should === method_name
-          end
-        end
-
-        it "overrides the method when passing a block" do
-          original_method = subject.method(:foobar)
-          Injections::DoubleInjection.find_or_create_by_subject(subject, method_name)
-          subject.method(:foobar).should_not == original_method
-        end
-      end
-
-      context "when double_injection exists" do
-        before do
-          def subject.foobar(*args)
-            :original_foobar
-          end
-
-          @method_name = :foobar
-        end
-
-        context "when a DoubleInjection is registered for the subject and method_name" do
-          it "returns the existing DoubleInjection" do
-            @double_injection = Injections::DoubleInjection.find_or_create_by_subject(subject, 'foobar')
-
-            double_injection.subject_has_original_method?.should be_true
-
-            Injections::DoubleInjection.find_or_create_by_subject(subject, 'foobar').should === double_injection
-
-            double_injection.reset
-            subject.foobar.should == :original_foobar
-          end
-        end
-      end
-    end
-
-    describe "#method_missing_injection" do
-      context "when existing subject == but not === with the same method name" do
-        it "creates a new DoubleInjection" do
-          subject_1 = []
-          subject_2 = []
-          (subject_1 === subject_2).should be_true
-          subject_1.__id__.should_not == subject_2.__id__
-
-          injection_1 = Injections::MethodMissingInjection.find_or_create(class << subject_1; self; end)
-          injection_2 = Injections::MethodMissingInjection.find_or_create(class << subject_2; self; end)
-
-          injection_1.should_not == injection_2
-        end
-      end
-
-      context "when a MethodMissingInjection is not registered for the subject and method_name" do
-        before do
-          def subject.method_missing(method_name, *args, &block)
-            :original_method_missing
-          end
-        end
-
-        it "overrides the method when passing a block" do
-          original_method = subject.method(:method_missing)
-          Injections::MethodMissingInjection.find_or_create(class << subject; self; end)
-          subject.method(:method_missing).should_not == original_method
-        end
-      end
-
-      context "when a MethodMissingInjection is registered for the subject and method_name" do
-        before do
-          def subject.method_missing(method_name, *args, &block)
-            :original_method_missing
-          end
-        end
-
-        context "when a DoubleInjection is registered for the subject and method_name" do
-          it "returns the existing DoubleInjection" do
-            injection = Injections::MethodMissingInjection.find_or_create(class << subject; self; end)
-            injection.subject_has_original_method?.should be_true
-
-            Injections::MethodMissingInjection.find_or_create(class << subject; self; end).should === injection
-
-            injection.reset
-            subject.method_missing(:foobar).should == :original_method_missing
-          end
-        end
-      end
-    end
-
-    describe "#singleton_method_added_injection" do
-      context "when existing subject == but not === with the same method name" do
-        it "creates a new DoubleInjection" do
-          subject_1 = []
-          subject_2 = []
-          (subject_1 === subject_2).should be_true
-          subject_1.__id__.should_not == subject_2.__id__
-
-          injection_1 = Injections::SingletonMethodAddedInjection.find_or_create(class << subject_1; self; end)
-          injection_2 = Injections::SingletonMethodAddedInjection.find_or_create(class << subject_2; self; end)
-
-          injection_1.should_not == injection_2
-        end
-      end
-
-      context "when a SingletonMethodAddedInjection is not registered for the subject and method_name" do
-        before do
-          def subject.singleton_method_added(method_name)
-            :original_singleton_method_added
-          end
-        end
-
-        it "overrides the method when passing a block" do
-          original_method = subject.method(:singleton_method_added)
-          Injections::SingletonMethodAddedInjection.find_or_create(class << subject; self; end)
-          subject.method(:singleton_method_added).should_not == original_method
-        end
-      end
-
-      context "when a SingletonMethodAddedInjection is registered for the subject and method_name" do
-        before do
-          def subject.singleton_method_added(method_name)
-            :original_singleton_method_added
-          end
-        end
-
-        context "when a DoubleInjection is registered for the subject and method_name" do
-          it "returns the existing DoubleInjection" do
-            injection = Injections::SingletonMethodAddedInjection.find_or_create(class << subject; self; end)
-            injection.subject_has_original_method?.should be_true
-
-            Injections::SingletonMethodAddedInjection.find_or_create(class << subject; self; end).should === injection
-
-            injection.reset
-            subject.singleton_method_added(:foobar).should == :original_singleton_method_added
-          end
-        end
-      end
-    end
-
-    describe "#reset" do
-      attr_reader :subject_1, :subject_2
-      before do
-        @subject_1 = Object.new
-        @subject_2 = Object.new
-        @method_name = :foobar
-      end
-
-      it "should clear the #recorded_calls" do
-        object = Object.new
-        space.record_call(object, :to_s, [], nil)
-
-        space.reset
-        space.recorded_calls.should == RR::RecordedCalls.new([])
-      end
-
-      it "removes the ordered doubles" do
-        mock(subject_1).foobar1.ordered
-        mock(subject_2).foobar2.ordered
-
-        space.ordered_doubles.should_not be_empty
-
-        space.reset
-        space.ordered_doubles.should be_empty
-      end
-
-      it "resets all double_injections" do
-        subject_1.respond_to?(method_name).should be_false
-        subject_2.respond_to?(method_name).should be_false
-
-        Injections::DoubleInjection.find_or_create_by_subject(subject_1, method_name)
-        Injections::DoubleInjection.exists_by_subject?(subject_1, method_name).should be_true
-        subject_1.respond_to?(method_name).should be_true
-
-        Injections::DoubleInjection.find_or_create_by_subject(subject_2, method_name)
-        Injections::DoubleInjection.exists_by_subject?(subject_2, method_name).should be_true
-        subject_2.respond_to?(method_name).should be_true
-
-        space.reset
-
-        subject_1.respond_to?(method_name).should be_false
-        Injections::DoubleInjection.exists?(subject_1, method_name).should be_false
-
-        subject_2.respond_to?(method_name).should be_false
-        Injections::DoubleInjection.exists?(subject_2, method_name).should be_false
-      end
-
-      it "resets all method_missing_injections" do
-        subject_1.respond_to?(:method_missing).should be_false
-        subject_2.respond_to?(:method_missing).should be_false
-
-        Injections::MethodMissingInjection.find_or_create(class << subject_1; self; end)
-        Injections::MethodMissingInjection.exists?(class << subject_1; self; end).should be_true
-        subject_1.respond_to?(:method_missing).should be_true
-
-        Injections::MethodMissingInjection.find_or_create(class << subject_2; self; end)
-        Injections::MethodMissingInjection.exists?(class << subject_2; self; end).should be_true
-        subject_2.respond_to?(:method_missing).should be_true
-
-        space.reset
-
-        subject_1.respond_to?(:method_missing).should be_false
-        Injections::MethodMissingInjection.exists?(subject_1).should be_false
-
-        subject_2.respond_to?(:method_missing).should be_false
-        Injections::MethodMissingInjection.exists?(subject_2).should be_false
-      end
-
-      it "resets all singleton_method_added_injections" do
-        subject_1.respond_to?(:singleton_method_added).should be_false
-        subject_2.respond_to?(:singleton_method_added).should be_false
-
-        Injections::SingletonMethodAddedInjection.find_or_create(class << subject_1; self; end)
-        Injections::SingletonMethodAddedInjection.exists?(class << subject_1; self; end).should be_true
-        subject_1.respond_to?(:singleton_method_added).should be_true
-
-        Injections::SingletonMethodAddedInjection.find_or_create(class << subject_2; self; end)
-        Injections::SingletonMethodAddedInjection.exists?(class << subject_2; self; end).should be_true
-        subject_2.respond_to?(:singleton_method_added).should be_true
-
-        space.reset
-
-        subject_1.respond_to?(:singleton_method_added).should be_false
-        Injections::SingletonMethodAddedInjection.exists?(subject_1).should be_false
-
-        subject_2.respond_to?(:singleton_method_added).should be_false
-        Injections::SingletonMethodAddedInjection.exists?(subject_2).should be_false
-      end
-
-      it "clears RR::Injections::DoubleInjection::BoundObjects" do
-        stub(subject).foobar
-        RR::Injections::DoubleInjection::BoundObjects.should_not be_empty
-        space.reset
-        pending "Clearing BoundObjects" do
-          RR::Injections::DoubleInjection::BoundObjects.should be_empty
-        end
-      end
-    end
-
-    describe "#reset_double" do
-      before do
-        @method_name = :foobar
-
-        def subject.foobar
-        end
-      end
-
-      it "resets the double_injections and restores the original method" do
-        original_method = subject.method(method_name)
-
-        @double_injection = Injections::DoubleInjection.find_or_create_by_subject(subject, method_name)
-        Injections::DoubleInjection.instances.keys.should include(class << subject; self; end)
-        Injections::DoubleInjection.find_by_subject(subject, method_name).should_not be_nil
-        subject.method(method_name).should_not == original_method
-
-        space.reset_double(subject, method_name)
-        Injections::DoubleInjection.instances.keys.should_not include(subject)
-        subject.method(method_name).should == original_method
-      end
-
-      context "when it has no double_injections" do
-        it "removes the subject from the double_injections map" do
-          double_1 = Injections::DoubleInjection.find_or_create_by_subject(subject, :foobar1)
-          double_2 = Injections::DoubleInjection.find_or_create_by_subject(subject, :foobar2)
-
-          Injections::DoubleInjection.instances.include?(class << subject; self; end).should == true
-          Injections::DoubleInjection.find_by_subject(subject, :foobar1).should_not be_nil
-          Injections::DoubleInjection.find_by_subject(subject, :foobar2).should_not be_nil
-
-          space.reset_double(subject, :foobar1)
-          Injections::DoubleInjection.instances.include?(class << subject; self; end).should == true
-          Injections::DoubleInjection.find_by_subject(subject, :foobar1).should be_nil
-          Injections::DoubleInjection.find_by_subject(subject, :foobar2).should_not be_nil
-
-          space.reset_double(subject, :foobar2)
-          Injections::DoubleInjection.instances.include?(subject).should == false
-        end
-      end
-    end
-
-    describe "#DoubleInjection.reset" do
-      attr_reader :subject_1, :subject_2
-      before do
-        @subject_1 = Object.new
-        @subject_2 = Object.new
-        @method_name = :foobar
-      end
-
-      it "resets the double_injection and removes it from the double_injections list" do
-        double_injection_1 = Injections::DoubleInjection.find_or_create_by_subject(subject_1, method_name)
-        double_1_reset_call_count = 0
-        ( class << double_injection_1; self; end).class_eval do
-          define_method(:reset) do
-            double_1_reset_call_count += 1
-          end
-        end
-        double_injection_2 = Injections::DoubleInjection.find_or_create_by_subject(subject_2, method_name)
-        double_2_reset_call_count = 0
-        ( class << double_injection_2; self; end).class_eval do
-          define_method(:reset) do
-            double_2_reset_call_count += 1
-          end
-        end
-
-        Injections::DoubleInjection.reset
-        double_1_reset_call_count.should == 1
-        double_2_reset_call_count.should == 1
-      end
-    end
-
-    describe "#verify_doubles" do
-      attr_reader :subject_1, :subject_2, :subject3, :double_1, :double_2, :double3
-      before do
-        @subject_1 = Object.new
-        @subject_2 = Object.new
-        @subject3 = Object.new
-        @method_name = :foobar
-        @double_1 = Injections::DoubleInjection.find_or_create_by_subject(subject_1, method_name)
-        @double_2 = Injections::DoubleInjection.find_or_create_by_subject(subject_2, method_name)
-        @double3 = Injections::DoubleInjection.find_or_create_by_subject(subject3, method_name)
-      end
-
-      context "when passed no arguments" do
-        it "verifies and deletes the double_injections" do
-          double_1_verify_call_count = 0
-          double_1_reset_call_count = 0
-          (
-          class << double_1;
-            self;
-          end).class_eval do
-            define_method(:verify) do
-              double_1_verify_call_count += 1
-            end
-            define_method(:reset) do
-              double_1_reset_call_count += 1
-            end
-          end
-
-          double_2_verify_call_count = 0
-          double_2_reset_call_count = 0
-          (
-          class << double_2;
-            self;
-          end).class_eval do
-            define_method(:verify) do
-              double_2_verify_call_count += 1
-            end
-            define_method(:reset) do
-              double_2_reset_call_count += 1
-            end
-          end
-
-          space.verify_doubles
-          double_1_verify_call_count.should == 1
-          double_2_verify_call_count.should == 1
-          double_1_reset_call_count.should == 1
-          double_1_reset_call_count.should == 1
-        end
-      end
-
-      context "when passed an Object that has at least one DoubleInjection" do
-        it "verifies all Doubles injected into the Object" do
-          double_1_verify_call_count = 0
-          double_1_reset_call_count = 0
-          (
-          class << double_1;
-            self;
-          end).class_eval do
-            define_method(:verify) do
-              double_1_verify_call_count += 1
-            end
-            define_method(:reset) do
-              double_1_reset_call_count += 1
-            end
-          end
-
-          double_2_verify_call_count = 0
-          double_2_reset_call_count = 0
-          (
-          class << double_2;
-            self;
-          end).class_eval do
-            define_method(:verify) do
-              double_2_verify_call_count += 1
-            end
-            define_method(:reset) do
-              double_2_reset_call_count += 1
-            end
-          end
-
-          space.verify_doubles(subject_1)
-
-          double_1_verify_call_count.should == 1
-          double_1_reset_call_count.should == 1
-          double_2_verify_call_count.should == 0
-          double_2_reset_call_count.should == 0
-        end
-      end
-
-      context "when passed multiple Objects with at least one DoubleInjection" do
-        it "verifies the Doubles injected into all of the Objects" do
-          double_1_verify_call_count = 0
-          double_1_reset_call_count = 0
-          ( class << double_1; self; end).class_eval do
-            define_method(:verify) do
-              double_1_verify_call_count += 1
-            end
-            define_method(:reset) do
-              double_1_reset_call_count += 1
-            end
-          end
-
-          double_2_verify_call_count = 0
-          double_2_reset_call_count = 0
-          ( class << double_2; self; end).class_eval do
-            define_method(:verify) do
-              double_2_verify_call_count += 1
-            end
-            define_method(:reset) do
-              double_2_reset_call_count += 1
-            end
-          end
-
-          double3_verify_call_count = 0
-          double3_reset_call_count = 0
-          ( class << double3; self; end).class_eval do
-            define_method(:verify) do
-              double3_verify_call_count += 1
-            end
-            define_method(:reset) do
-              double3_reset_call_count += 1
-            end
-          end
-
-          space.verify_doubles(subject_1, subject_2)
-
-          double_1_verify_call_count.should == 1
-          double_1_reset_call_count.should == 1
-          double_2_verify_call_count.should == 1
-          double_2_reset_call_count.should == 1
-          double3_verify_call_count.should == 0
-          double3_reset_call_count.should == 0
-        end
-      end
-
-      context "when passed an subject that does not have a DoubleInjection" do
-        it "does not raise an error" do
-          double_1_verify_call_count = 0
-          double_1_reset_call_count = 0
-          ( class << double_1; self; end).class_eval do
-            define_method(:verify) do
-              double_1_verify_call_count += 1
-            end
-            define_method(:reset) do
-              double_1_reset_call_count += 1
-            end
-          end
-
-          double_2_verify_call_count = 0
-          double_2_reset_call_count = 0
-          ( class << double_2; self; end).class_eval do
-            define_method(:verify) do
-              double_2_verify_call_count += 1
-            end
-            define_method(:reset) do
-              double_2_reset_call_count += 1
-            end
-          end
-
-          double3_verify_call_count = 0
-          double3_reset_call_count = 0
-          ( class << double3; self; end).class_eval do
-            define_method(:verify) do
-              double3_verify_call_count += 1
-            end
-            define_method(:reset) do
-              double3_reset_call_count += 1
-            end
-          end
-
-          no_double_injection_object = Object.new
-          space.verify_doubles(no_double_injection_object)
-
-          double_1_verify_call_count.should == 0
-          double_1_reset_call_count.should == 0
-          double_2_verify_call_count.should == 0
-          double_2_reset_call_count.should == 0
-          double3_verify_call_count.should == 0
-          double3_reset_call_count.should == 0
-        end
-      end
-    end
-
-    describe "#verify_double" do
-      before do
-        @method_name = :foobar
-
-        def subject.foobar
-        end
-      end
-
-      it "verifies and deletes the double_injection" do
-        @double_injection = Injections::DoubleInjection.find_or_create_by_subject(subject, method_name)
-        Injections::DoubleInjection.find_by_subject(subject, method_name).should === double_injection
-
-        verify_call_count = 0
-        ( class << double_injection; self; end).class_eval do
-          define_method(:verify) do
-            verify_call_count += 1
-          end
-        end
-        space.verify_double(subject, method_name)
-        verify_call_count.should == 1
-
-        Injections::DoubleInjection.find(subject, method_name).should be_nil
-      end
-
-      context "when verifying the double_injection raises an error" do
-        it "deletes the double_injection and restores the original method" do
-          original_method = subject.method(method_name)
-
-          @double_injection = Injections::DoubleInjection.find_or_create_by_subject(subject, method_name)
-          subject.method(method_name).should_not == original_method
-
-          Injections::DoubleInjection.find_by_subject(subject, method_name).should === double_injection
-
-          verify_called = true
-          ( class << double_injection; self; end).class_eval do
-            define_method(:verify) do
-              verify_called = true
-              raise "An Error"
-            end
-          end
-          lambda {space.verify_double(subject, method_name)}.should raise_error
-          verify_called.should be_true
-
-          Injections::DoubleInjection.find(subject, method_name).should be_nil
-          subject.method(method_name).should == original_method
-        end
-      end
-    end
-  end
-end