rr 0.10.11 → 1.0.0

data/spec/api/any_instance_of/all_instances_of_spec.rb

@@ -0,0 +1,14 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+describe "all_instances_of" do
+  it "applies to instances instantiated before the Double expection was created" do
+    pending("Completion of all_instances_of") do
+      subject_class = Class.new
+      subject = subject_class.new
+      all_instances_of(subject_class) do |o|
+        o.to_s {"Subject is stubbed"}
+      end
+      subject.to_s.should == "Subject is stubbed"
+    end
+  end
+end

data/spec/api/any_instance_of/any_instance_of_spec.rb

@@ -0,0 +1,47 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+describe "any_instance_of" do
+  context "when passed a block" do
+    it "applies to instances instantiated before the Double expection was created" do
+      subject_class = Class.new
+      subject = subject_class.new
+      class_called = false
+      any_instance_of(subject_class) do |o|
+        stub(o).to_s {"Subject is stubbed"}
+        stub.proxy(o).class {|klass| class_called = true; klass}
+        stub(o).foobar {:baz}
+      end
+
+      subject.to_s.should == "Subject is stubbed"
+      subject.class.should == subject_class
+      class_called.should == true
+      subject.foobar.should == :baz
+
+      RR.reset
+
+      subject.to_s.should_not == "Subject is stubbed"
+      class_called = false
+      subject.class.should == subject_class
+      class_called.should == false
+      subject.should_not respond_to(:baz)
+    end
+  end
+
+  context "when passed a Hash" do
+    it "stubs methods (key) with the value on instances instantiated before the Double expection was created" do
+      subject_class = Class.new
+      subject = subject_class.new
+      subject.should_not respond_to(:baz)
+
+      any_instance_of(subject_class, :to_s => "Subject is stubbed", :foobar => lambda {:baz})
+
+      subject.to_s.should == "Subject is stubbed"
+      subject.foobar.should == :baz
+
+      RR.reset
+
+      subject.to_s.should_not == "Subject is stubbed"
+      subject.should_not respond_to(:baz)
+    end
+  end
+end

data/spec/api/mock/mock_spec.rb

@@ -169,10 +169,10 @@ describe "mock" do
       SampleClass1.hello.should == "hola!"
     end
 
-    it "should not break when it is mocked on subclass" do
+    it "does not override subclasses" do
       mock(SampleClass1).hello { "hi!" }
 
-      SampleClass2.hello.should == "hi!"
+      SampleClass2.hello.should == "hello!"
     end
 
     it "should not get affected from a previous example" do

data/spec/api/new_instance_of/instance_of_spec.rb

@@ -0,0 +1,15 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+describe "instance_of" do
+  it "applies to instances instantiated before the Double expection was created" do
+    subject_class = Class.new
+    existing_subject = subject_class.new
+    stub.instance_of(subject_class) do |o|
+      o.to_s {"Subject is stubbed"}
+    end
+    new_subject = subject_class.new
+
+    existing_subject.to_s.should_not == "Subject is stubbed"
+    new_subject.to_s.should == "Subject is stubbed"
+  end
+end

data/spec/api/new_instance_of/new_instance_of_spec.rb

@@ -0,0 +1,61 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+describe "new_instance_of" do
+  context "when passed a method chain" do
+    it "stubs the called method name with the given value" do
+      subject_class = Class.new
+      existing_subject = subject_class.new
+      new_instance_of(subject_class).foobar {:baz}
+
+      subject_new = subject_class.new
+      existing_subject.should_not respond_to(:foobar)
+      subject_new.foobar.should == :baz
+
+      subject_allocate = subject_class.allocate
+      existing_subject.should_not respond_to(:foobar)
+      subject_allocate.foobar.should == :baz
+    end
+  end
+
+  context "when passed a block" do
+    it "applies to instances instantiated before the Double expection was created" do
+      subject_class = Class.new
+      existing_subject = subject_class.new
+      class_called = false
+      new_instance_of(subject_class) do |o|
+        stub(o).to_s {"Subject is stubbed"}
+        stub.proxy(o).class {|klass| class_called = true; klass}
+      end
+
+      existing_subject.to_s.should_not == "Subject is stubbed"
+
+      subject_new = subject_class.new
+      subject_new.to_s.should == "Subject is stubbed"
+      subject_new.class.should == subject_class
+      class_called.should be_true
+
+      subject_allocate = subject_class.allocate
+      subject_allocate.to_s.should == "Subject is stubbed"
+      subject_allocate.class.should == subject_class
+    end
+  end
+
+  context "when passed a Hash" do
+    it "stubs methods (key) with the value on instances instantiated before the Double expection was created" do
+      subject_class = Class.new
+      existing_subject = subject_class.new
+      new_instance_of(subject_class, :to_s => "Subject is stubbed", :foobar => lambda {:baz})
+
+      existing_subject.to_s.should_not == "Subject is stubbed"
+      existing_subject.should_not respond_to(:foobar)
+
+      subject_new = subject_class.new
+      subject_new.to_s.should == "Subject is stubbed"
+      subject_new.foobar.should == :baz
+      
+      subject_allocate = subject_class.allocate
+      subject_allocate.to_s.should == "Subject is stubbed"
+      subject_allocate.foobar.should == :baz
+    end
+  end
+end

data/spec/environment_fixture_setup.rb

@@ -1,7 +1,8 @@
 require "rubygems"
 require "spec"
 require "spec/autorun"
-dir = File.dirname(__FILE__)
-$LOAD_PATH.unshift "#{dir}/../lib"
+require "bundler"
+
+$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../lib"
 require "rr"
 require "pp"

data/spec/rr/adapters/rr_methods_space_spec.rb

@@ -20,7 +20,7 @@ module RR
 
       describe "#rr_verify" do
         it "verifies and deletes the double_injections" do
-          double_1 = Injections::DoubleInjection.create(subject_1, method_name)
+          double_1 = ::RR::Injections::DoubleInjection.find_or_create_by_subject(subject_1, method_name)
           double_1_verify_calls = 0
           double_1_reset_calls = 0
           (
@@ -34,13 +34,10 @@ module RR
               double_1_reset_calls += 1
             end
           end
-          double_2 = Injections::DoubleInjection.create(subject_2, method_name)
+          double_2 = ::RR::Injections::DoubleInjection.find_or_create_by_subject(subject_2, method_name)
           double_2_verify_calls = 0
           double_2_reset_calls = 0
-          (
-          class << double_2;
-            self;
-          end).class_eval do
+          ( class << double_2; self; end).class_eval do
             define_method(:verify) do ||
               double_2_verify_calls += 1
             end
@@ -68,21 +65,22 @@ module RR
           mock(subject_1).foobar1.ordered
           mock(subject_2).foobar2.ordered
 
-          Injections::DoubleInjection.instances.should_not be_empty
+          ::RR::Injections::DoubleInjection.instances.should_not be_empty
 
           rr_reset
-          Injections::DoubleInjection.instances.should be_empty
+          ::RR::Injections::DoubleInjection.instances
+          ::RR::Injections::DoubleInjection.instances.should be_empty
         end
 
         it "resets all double_injections" do
-          double_1 = Injections::DoubleInjection.create(subject_1, method_name)
+          double_1 = ::RR::Injections::DoubleInjection.find_or_create_by_subject(subject_1, method_name)
           double_1_reset_calls = 0
           ( class << double_1; self; end).class_eval do
             define_method(:reset) do ||
               double_1_reset_calls += 1
             end
           end
-          double_2 = Injections::DoubleInjection.create(subject_2, method_name)
+          double_2 = ::RR::Injections::DoubleInjection.find_or_create_by_subject(subject_2, method_name)
           double_2_reset_calls = 0
           ( class << double_2; self; end).class_eval do
             define_method(:reset) do ||

data/spec/rr/double_definitions/child_double_definition_creator_spec.rb

@@ -86,7 +86,7 @@ module RR
         end
       end
 
-      describe "Strategies::Scope definitions" do
+      describe "Strategies::DoubleInjection definitions" do
         describe "methods without !" do
           describe "#instance_of" do
             it "raises a NoMethodError" do

data/spec/rr/double_definitions/double_definition_create_blank_slate_spec.rb

@@ -51,7 +51,9 @@ module RR
             end
 
             it "passes the self into the block" do
-              passed_in_argument.__double_definition_create__.should be_instance_of(DoubleDefinitions::DoubleDefinitionCreate)
+              passed_in_argument.__double_definition_create__.should be_instance_of(
+                ::RR::DoubleDefinitions::DoubleDefinitionCreate
+              )
             end
           end
 
@@ -77,7 +79,9 @@ module RR
             end
 
             it "evaluates the block with the context of self" do
-              self_value.__double_definition_create__.should be_instance_of(DoubleDefinitions::DoubleDefinitionCreate)
+              self_value.__double_definition_create__.should be_instance_of(
+                ::RR::DoubleDefinitions::DoubleDefinitionCreate
+              )
             end
           end
         end

data/spec/rr/double_definitions/double_definition_create_spec.rb

@@ -43,15 +43,6 @@ module RR
                 subject.foobar.should == :baz
               end
             end
-
-            context "when already using an ImplementationStrategy" do
-              it "raises a DoubleDefinitionError" do
-                double_definition_create.mock
-                lambda do
-                  call_strategy
-                end.should raise_error(RR::Errors::DoubleDefinitionError, "This Double already has a mock strategy")
-              end
-            end
           end
 
           describe "#stub" do
@@ -73,15 +64,6 @@ module RR
                 subject.foobar.should == :baz
               end
             end
-
-            context "when already using an ImplementationStrategy" do
-              it "raises a DoubleDefinitionError" do
-                double_definition_create.mock
-                lambda do
-                  call_strategy
-                end.should raise_error(RR::Errors::DoubleDefinitionError, "This Double already has a mock strategy")
-              end
-            end
           end
 
           describe "#dont_allow" do
@@ -95,13 +77,6 @@ module RR
               end
             end
 
-            it "raises error when proxied" do
-              double_definition_create.proxy
-              lambda do
-                double_definition_create.dont_allow
-              end.should raise_error(RR::Errors::DoubleDefinitionError, "Doubles cannot be proxied when using dont_allow strategy")
-            end
-
             context "when passed a subject and a method_name argument_expectation" do
               it "creates a mock Double for method" do
                 double_definition = double_definition_create.dont_allow(subject, :foobar)
@@ -114,15 +89,6 @@ module RR
                 RR.reset
               end
             end
-
-            context "when already using an ImplementationStrategy" do
-              it "raises a DoubleDefinitionError" do
-                double_definition_create.mock
-                lambda do
-                  call_strategy
-                end.should raise_error(RR::Errors::DoubleDefinitionError, "This Double already has a mock strategy")
-              end
-            end
           end
         end
 
@@ -182,15 +148,6 @@ module RR
             end
           end
 
-          context "when already using Strategies::Verification::DontAllow" do
-            it "raises error" do
-              double_definition_create.dont_allow
-              lambda do
-                double_definition_create.proxy
-              end.should raise_error(RR::Errors::DoubleDefinitionError, "Doubles cannot be proxied when using dont_allow strategy")
-            end
-          end
-
           context "when passed a method_name argument" do
             it "creates a proxy Double for method" do
               double_definition = double_definition_create.stub.proxy(subject, :foobar).after_call {:baz}
@@ -205,7 +162,7 @@ module RR
           context "when not passed a class" do
             it "raises an ArgumentError" do
               lambda do
-                double_definition_create.instance_of(Object.new)
+                double_definition_create.instance_of(Object.new).foobar
               end.should raise_error(ArgumentError, "instance_of only accepts class objects")
             end
           end
@@ -248,14 +205,6 @@ module RR
 
       describe "StrategyExecutionMethods" do
         describe "#create" do
-          context "when #verification_strategy is not set" do
-            it "raises a DoubleDefinitionError" do
-              lambda do
-                double_definition_create.call(:foobar, 1, 2)
-              end.should raise_error(RR::Errors::DoubleDefinitionError, "This Double has no strategy")
-            end
-          end
-
           context "when #verification_strategy is a Mock" do
             context "when #implementation_strategy is a Reimplementation" do
               before do

data/spec/rr/double_injection/double_injection_verify_spec.rb

@@ -9,7 +9,7 @@ module RR
         @subject = Object.new
         @method_name = :foobar
         subject.methods.should_not include(method_name.to_s)
-        @double_injection = Injections::DoubleInjection.create(subject, method_name)
+        @double_injection = ::RR::Injections::DoubleInjection.find_or_create_by_subject(subject, method_name)
       end
 
       it "verifies each double was met" do

data/spec/rr/rspec/rspec_adapter_spec.rb

@@ -15,10 +15,10 @@ module RR
 
         it "resets the double_injections" do
           stub(subject).foobar
-          Injections::DoubleInjection.instances.should_not be_empty
+          ::RR::Injections::DoubleInjection.instances.should_not be_empty
 
           fixture.setup_mocks_for_rspec
-          Injections::DoubleInjection.instances.should be_empty
+          ::RR::Injections::DoubleInjection.instances.should be_empty
         end
       end
 
@@ -37,7 +37,7 @@ module RR
           lambda do
             fixture.verify_mocks_for_rspec
           end.should raise_error(::RR::Errors::TimesCalledError)
-          Injections::DoubleInjection.instances.should be_empty
+          ::RR::Injections::DoubleInjection.instances.should be_empty
         end
       end
 
@@ -52,10 +52,10 @@ module RR
 
         it "resets the double_injections" do
           stub(subject).foobar
-          Injections::DoubleInjection.instances.should_not be_empty
+          ::RR::Injections::DoubleInjection.instances.should_not be_empty
 
           fixture.teardown_mocks_for_rspec
-          Injections::DoubleInjection.instances.should be_empty
+          ::RR::Injections::DoubleInjection.instances.should be_empty
         end
       end
     end

data/spec/rr/space/space_spec.rb

@@ -26,8 +26,8 @@ module RR
           (subject_1 === subject_2).should be_true
           subject_1.__id__.should_not == subject_2.__id__
 
-          injection_1 = Injections::DoubleInjection.create(subject_1, :foobar)
-          injection_2 = Injections::DoubleInjection.create(subject_2, :foobar)
+          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
@@ -44,25 +44,25 @@ module RR
 
         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.create(subject, method_name)
-            Injections::DoubleInjection.create(subject, method_name).should === double_injection
-            double_injection.subject.should === subject
+            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.create(subject, 'foobar')
-            Injections::DoubleInjection.create(subject, method_name).should === double_injection
-            double_injection.subject.should === subject
+            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.create(subject, method_name)
+          Injections::DoubleInjection.find_or_create_by_subject(subject, method_name)
           subject.method(:foobar).should_not == original_method
         end
       end
@@ -78,11 +78,11 @@ module RR
 
         context "when a DoubleInjection is registered for the subject and method_name" do
           it "returns the existing DoubleInjection" do
-            @double_injection = Injections::DoubleInjection.create(subject, 'foobar')
+            @double_injection = Injections::DoubleInjection.find_or_create_by_subject(subject, 'foobar')
 
             double_injection.subject_has_original_method?.should be_true
 
-            Injections::DoubleInjection.create(subject, 'foobar').should === double_injection
+            Injections::DoubleInjection.find_or_create_by_subject(subject, 'foobar').should === double_injection
 
             double_injection.reset
             subject.foobar.should == :original_foobar
@@ -99,8 +99,8 @@ module RR
           (subject_1 === subject_2).should be_true
           subject_1.__id__.should_not == subject_2.__id__
 
-          injection_1 = Injections::MethodMissingInjection.create(subject_1)
-          injection_2 = Injections::MethodMissingInjection.create(subject_2)
+          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
@@ -115,7 +115,7 @@ module RR
 
         it "overrides the method when passing a block" do
           original_method = subject.method(:method_missing)
-          Injections::MethodMissingInjection.create(subject)
+          Injections::MethodMissingInjection.find_or_create(class << subject; self; end)
           subject.method(:method_missing).should_not == original_method
         end
       end
@@ -129,10 +129,10 @@ module RR
 
         context "when a DoubleInjection is registered for the subject and method_name" do
           it "returns the existing DoubleInjection" do
-            injection = Injections::MethodMissingInjection.create(subject)
+            injection = Injections::MethodMissingInjection.find_or_create(class << subject; self; end)
             injection.subject_has_original_method?.should be_true
 
-            Injections::MethodMissingInjection.create(subject).should === injection
+            Injections::MethodMissingInjection.find_or_create(class << subject; self; end).should === injection
 
             injection.reset
             subject.method_missing(:foobar).should == :original_method_missing
@@ -149,8 +149,8 @@ module RR
           (subject_1 === subject_2).should be_true
           subject_1.__id__.should_not == subject_2.__id__
 
-          injection_1 = Injections::SingletonMethodAddedInjection.create(subject_1)
-          injection_2 = Injections::SingletonMethodAddedInjection.create(subject_2)
+          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
@@ -165,7 +165,7 @@ module RR
 
         it "overrides the method when passing a block" do
           original_method = subject.method(:singleton_method_added)
-          Injections::SingletonMethodAddedInjection.create(subject)
+          Injections::SingletonMethodAddedInjection.find_or_create(class << subject; self; end)
           subject.method(:singleton_method_added).should_not == original_method
         end
       end
@@ -179,10 +179,10 @@ module RR
 
         context "when a DoubleInjection is registered for the subject and method_name" do
           it "returns the existing DoubleInjection" do
-            injection = Injections::SingletonMethodAddedInjection.create(subject)
+            injection = Injections::SingletonMethodAddedInjection.find_or_create(class << subject; self; end)
             injection.subject_has_original_method?.should be_true
 
-            Injections::SingletonMethodAddedInjection.create(subject).should === injection
+            Injections::SingletonMethodAddedInjection.find_or_create(class << subject; self; end).should === injection
 
             injection.reset
             subject.singleton_method_added(:foobar).should == :original_singleton_method_added
@@ -221,12 +221,12 @@ module RR
         subject_1.respond_to?(method_name).should be_false
         subject_2.respond_to?(method_name).should be_false
 
-        Injections::DoubleInjection.create(subject_1, method_name)
-        Injections::DoubleInjection.exists?(subject_1, method_name).should be_true
+        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.create(subject_2, method_name)
-        Injections::DoubleInjection.exists?(subject_2, 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
@@ -242,12 +242,12 @@ module RR
         subject_1.respond_to?(:method_missing).should be_false
         subject_2.respond_to?(:method_missing).should be_false
 
-        Injections::MethodMissingInjection.create(subject_1)
-        Injections::MethodMissingInjection.exists?(subject_1).should be_true
+        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.create(subject_2)
-        Injections::MethodMissingInjection.exists?(subject_2).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
@@ -263,12 +263,12 @@ module RR
         subject_1.respond_to?(:singleton_method_added).should be_false
         subject_2.respond_to?(:singleton_method_added).should be_false
 
-        Injections::SingletonMethodAddedInjection.create(subject_1)
-        Injections::SingletonMethodAddedInjection.exists?(subject_1).should be_true
+        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.create(subject_2)
-        Injections::SingletonMethodAddedInjection.exists?(subject_2).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
@@ -292,9 +292,9 @@ module RR
       it "resets the double_injections and restores the original method" do
         original_method = subject.method(method_name)
 
-        @double_injection = Injections::DoubleInjection.create(subject, method_name)
-        Injections::DoubleInjection.instances.keys.should include(subject)
-        Injections::DoubleInjection.instances[subject].keys.should include(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)
@@ -304,17 +304,17 @@ module RR
 
       context "when it has no double_injections" do
         it "removes the subject from the double_injections map" do
-          double_1 = Injections::DoubleInjection.create(subject, :foobar1)
-          double_2 = Injections::DoubleInjection.create(subject, :foobar2)
+          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?(subject).should == true
-          Injections::DoubleInjection.instances[subject][:foobar1].should_not be_nil
-          Injections::DoubleInjection.instances[subject][:foobar2].should_not be_nil
+          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?(subject).should == true
-          Injections::DoubleInjection.instances[subject][:foobar1].should be_nil
-          Injections::DoubleInjection.instances[subject][:foobar2].should_not be_nil
+          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
@@ -331,14 +331,14 @@ module RR
       end
 
       it "resets the double_injection and removes it from the double_injections list" do
-        double_injection_1 = Injections::DoubleInjection.create(subject_1, method_name)
+        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.create(subject_2, method_name)
+        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
@@ -359,9 +359,9 @@ module RR
         @subject_2 = Object.new
         @subject3 = Object.new
         @method_name = :foobar
-        @double_1 = Injections::DoubleInjection.create(subject_1, method_name)
-        @double_2 = Injections::DoubleInjection.create(subject_2, method_name)
-        @double3 = Injections::DoubleInjection.create(subject3, method_name)
+        @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
@@ -445,10 +445,7 @@ module RR
         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
+          ( class << double_1; self; end).class_eval do
             define_method(:verify) do
               double_1_verify_call_count += 1
             end
@@ -459,10 +456,7 @@ module RR
 
           double_2_verify_call_count = 0
           double_2_reset_call_count = 0
-          (
-          class << double_2;
-            self;
-          end).class_eval do
+          ( class << double_2; self; end).class_eval do
             define_method(:verify) do
               double_2_verify_call_count += 1
             end
@@ -473,10 +467,7 @@ module RR
 
           double3_verify_call_count = 0
           double3_reset_call_count = 0
-          (
-          class << double3;
-            self;
-          end).class_eval do
+          ( class << double3; self; end).class_eval do
             define_method(:verify) do
               double3_verify_call_count += 1
             end
@@ -553,8 +544,8 @@ module RR
       end
 
       it "verifies and deletes the double_injection" do
-        @double_injection = Injections::DoubleInjection.create(subject, method_name)
-        Injections::DoubleInjection.instances[subject][method_name].should === double_injection
+        @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
@@ -565,17 +556,17 @@ module RR
         space.verify_double(subject, method_name)
         verify_call_count.should == 1
 
-        Injections::DoubleInjection.instances[subject][method_name].should be_nil
+        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.create(subject, method_name)
+          @double_injection = Injections::DoubleInjection.find_or_create_by_subject(subject, method_name)
           subject.method(method_name).should_not == original_method
 
-          Injections::DoubleInjection.instances[subject][method_name].should === double_injection
+          Injections::DoubleInjection.find_by_subject(subject, method_name).should === double_injection
 
           verify_called = true
           ( class << double_injection; self; end).class_eval do
@@ -587,7 +578,7 @@ module RR
           lambda {space.verify_double(subject, method_name)}.should raise_error
           verify_called.should be_true
 
-          Injections::DoubleInjection.instances[subject][method_name].should be_nil
+          Injections::DoubleInjection.find(subject, method_name).should be_nil
           subject.method(method_name).should == original_method
         end
       end