rr 0.10.10 → 0.10.11

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 = space.double_injection(subject_1, method_name)
+          double_1 = Injections::DoubleInjection.create(subject_1, method_name)
           double_1_verify_calls = 0
           double_1_reset_calls = 0
           (
@@ -34,7 +34,7 @@ module RR
               double_1_reset_calls += 1
             end
           end
-          double_2 = space.double_injection(subject_2, method_name)
+          double_2 = Injections::DoubleInjection.create(subject_2, method_name)
           double_2_verify_calls = 0
           double_2_reset_calls = 0
           (
@@ -65,41 +65,26 @@ module RR
 
       describe "#rr_reset" do
         it "removes the ordered doubles" do
-          double_1 = new_double(
-            space.double_injection(subject_1, :foobar1),
-            RR::DoubleDefinitions::DoubleDefinition.new(creator = RR::DoubleDefinitions::DoubleDefinitionCreator.new, subject_1)
-          )
-          double_2 = new_double(
-            space.double_injection(subject_2, :foobar2),
-            RR::DoubleDefinitions::DoubleDefinition.new(creator = RR::DoubleDefinitions::DoubleDefinitionCreator.new, subject_2)
-          )
+          mock(subject_1).foobar1.ordered
+          mock(subject_2).foobar2.ordered
 
-          double_1.definition.ordered
-          double_2.definition.ordered
-
-          space.ordered_doubles.should_not be_empty
+          Injections::DoubleInjection.instances.should_not be_empty
 
           rr_reset
-          space.ordered_doubles.should be_empty
+          Injections::DoubleInjection.instances.should be_empty
         end
 
         it "resets all double_injections" do
-          double_1 = space.double_injection(subject_1, method_name)
+          double_1 = Injections::DoubleInjection.create(subject_1, method_name)
           double_1_reset_calls = 0
-          (
-          class << double_1;
-            self;
-          end).class_eval do
+          ( class << double_1; self; end).class_eval do
             define_method(:reset) do ||
               double_1_reset_calls += 1
             end
           end
-          double_2 = space.double_injection(subject_2, method_name)
+          double_2 = Injections::DoubleInjection.create(subject_2, method_name)
           double_2_reset_calls = 0
-          (
-          class << double_2;
-            self;
-          end).class_eval do
+          ( class << double_2; self; end).class_eval do
             define_method(:reset) do ||
               double_2_reset_calls += 1
             end

data/spec/rr/double_definitions/child_double_definition_creator_spec.rb

@@ -2,22 +2,22 @@ require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
 
 module RR
   module DoubleDefinitions
-    describe ChildDoubleDefinitionCreator do
-      attr_reader :parent_subject, :parent_double_definition_creator, :parent_double_definition, :child_double_definition_creator
+    describe ChildDoubleDefinitionCreate do
+      attr_reader :parent_subject, :parent_double_definition_create, :parent_double_definition, :child_double_definition_create
       it_should_behave_like "Swapped Space"
       before(:each) do
         @parent_subject = Object.new
-        @parent_double_definition_creator = DoubleDefinitionCreator.new
-        @parent_double_definition = DoubleDefinition.new(parent_double_definition_creator, parent_subject)
-        @child_double_definition_creator = ChildDoubleDefinitionCreator.new(parent_double_definition)
+        @parent_double_definition_create = DoubleDefinitionCreate.new
+        @parent_double_definition = DoubleDefinition.new(parent_double_definition_create)
+        @child_double_definition_create = ChildDoubleDefinitionCreate.new(parent_double_definition)
       end
 
       describe "#root_subject" do
         it "returns the #parent_double_definition.root_subject" do
           child_subject = Object.new
-          parent_double_definition_creator.stub(parent_subject)
-          child_double_definition_creator.stub(child_subject)
-          child_double_definition_creator.root_subject.should == parent_subject
+          parent_double_definition_create.stub(parent_subject)
+          child_double_definition_create.stub(child_subject)
+          child_double_definition_create.root_subject.should == parent_subject
         end
       end      
       
@@ -32,7 +32,7 @@ module RR
             context "when passed a subject" do
               it "sets #parent_double_definition.implementation to a Proc returning the passed-in subject" do
                 parent_double_definition.implementation.should be_nil
-                child_double_definition_creator.mock(child_subject)
+                child_double_definition_create.mock(child_subject)
                 parent_double_definition.implementation.call.should == child_subject
               end
             end
@@ -42,7 +42,7 @@ module RR
             context "when passed a subject" do
               it "sets #parent_double_definition.implementation to a Proc returning the passed-in subject" do
                 parent_double_definition.implementation.should be_nil
-                child_double_definition_creator.stub(child_subject)
+                child_double_definition_create.stub(child_subject)
                 parent_double_definition.implementation.call.should == child_subject
               end
             end
@@ -52,7 +52,7 @@ module RR
             context "when passed a subject" do
               it "sets #parent_double_definition.implementation to a Proc returning the passed-in subject" do
                 parent_double_definition.implementation.should be_nil
-                child_double_definition_creator.dont_allow(child_subject)
+                child_double_definition_create.dont_allow(child_subject)
                 parent_double_definition.implementation.call.should == child_subject
               end
             end
@@ -63,7 +63,7 @@ module RR
           describe "#mock!" do
             it "sets #parent_double_definition.implementation to a Proc returning the #subject" do
               parent_double_definition.implementation.should be_nil
-              child_subject = child_double_definition_creator.mock!.__creator__.subject
+              child_subject = child_double_definition_create.mock!.__double_definition_create__.subject
               parent_double_definition.implementation.call.should == child_subject
             end
           end
@@ -71,7 +71,7 @@ module RR
           describe "#stub!" do
             it "sets #parent_double_definition.implementation to a Proc returning the #subject" do
               parent_double_definition.implementation.should be_nil
-              child_subject = child_double_definition_creator.stub!.__creator__.subject
+              child_subject = child_double_definition_create.stub!.__double_definition_create__.subject
               parent_double_definition.implementation.call.should == child_subject
             end
           end
@@ -79,7 +79,7 @@ module RR
           describe "#dont_allow!" do
             it "sets #parent_double_definition.implementation to a Proc returning the #subject" do
               parent_double_definition.implementation.should be_nil
-              child_subject = child_double_definition_creator.dont_allow!.__creator__.subject
+              child_subject = child_double_definition_create.dont_allow!.__double_definition_create__.subject
               parent_double_definition.implementation.call.should == child_subject
             end
           end
@@ -91,7 +91,7 @@ module RR
           describe "#instance_of" do
             it "raises a NoMethodError" do
               lambda do
-                child_double_definition_creator.instance_of
+                child_double_definition_create.instance_of
               end.should raise_error(NoMethodError)
             end
           end
@@ -101,7 +101,7 @@ module RR
           describe "#instance_of!" do
             it "raises a NoMethodError" do
               lambda do
-                child_double_definition_creator.instance_of!
+                child_double_definition_create.instance_of!
               end.should raise_error(NoMethodError)
             end
           end

data/spec/rr/double_definitions/double_definition_create_blank_slate_spec.rb

@@ -0,0 +1,87 @@
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
+
+module RR
+  module DoubleDefinitions
+    describe DoubleDefinitionCreateBlankSlate do
+      attr_reader :subject, :double_definition_create, :blank_slate
+      it_should_behave_like "Swapped Space"
+
+      before(:each) do
+        @subject = Object.new
+        @double_definition_create = DoubleDefinitionCreate.new
+        double_definition_create.mock(subject)
+      end
+
+      describe ".new" do
+        it "does not undefine object_id" do
+          blank_slate = DoubleDefinitionCreateBlankSlate.new(double_definition_create)
+          blank_slate.object_id.class.should == Fixnum
+        end
+
+        context "without block" do
+          before do
+            @blank_slate = DoubleDefinitionCreateBlankSlate.new(double_definition_create)
+          end
+
+          it "clears out all methods from proxy" do
+            stub(subject).i_should_be_a_double.should be_instance_of(DoubleDefinition)
+          end
+        end
+
+        context "when passed a block" do
+          context "when the block has an arity of 1" do
+            attr_reader :passed_in_argument
+            before do
+              passed_in_argument = nil
+              stub(subject) do |b|
+                passed_in_argument = b
+                b.foobar(1, 2) {:one_two}
+                b.foobar(1) {:one}
+                b.foobar.with_any_args {:default}
+                b.baz() {:baz_result}
+              end
+              @passed_in_argument = passed_in_argument
+            end
+
+            it "creates double_injections" do
+              subject.foobar(1, 2).should == :one_two
+              subject.foobar(1).should == :one
+              subject.foobar(:something).should == :default
+              subject.baz.should == :baz_result
+            end
+
+            it "passes the self into the block" do
+              passed_in_argument.__double_definition_create__.should be_instance_of(DoubleDefinitions::DoubleDefinitionCreate)
+            end
+          end
+
+          context "when the block has an arity of 0" do
+            attr_reader :self_value
+            before do
+              self_value = nil
+              stub(subject) do ||
+                self_value = self
+                foobar(1, 2) {:one_two}
+                foobar(1) {:one}
+                foobar.with_any_args {:default}
+                baz() {:baz_result}
+              end
+              @self_value = self_value
+            end
+
+            it "creates double_injections" do
+              subject.foobar(1, 2).should == :one_two
+              subject.foobar(1).should == :one
+              subject.foobar(:something).should == :default
+              subject.baz.should == :baz_result
+            end
+
+            it "evaluates the block with the context of self" do
+              self_value.__double_definition_create__.should be_instance_of(DoubleDefinitions::DoubleDefinitionCreate)
+            end
+          end
+        end
+      end
+    end    
+  end
+end

data/spec/rr/double_definitions/{double_definition_creator_spec.rb → double_definition_create_spec.rb}

@@ -2,25 +2,25 @@ require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
 
 module RR
   module DoubleDefinitions
-    describe DoubleDefinitionCreator do
-      attr_reader :creator, :subject, :strategy_method_name
+    describe DoubleDefinitionCreate do
+      attr_reader :double_definition_create, :subject, :strategy_method_name
       it_should_behave_like "Swapped Space"
       before(:each) do
         @subject = Object.new
-        @creator = DoubleDefinitionCreator.new
+        @double_definition_create = DoubleDefinitionCreate.new
       end
 
       describe "#root_subject" do
         it "returns #subject" do
-          creator.stub(subject).foobar
-          creator.root_subject.should == subject
+          double_definition_create.stub(subject).foobar
+          double_definition_create.root_subject.should == subject
         end
       end
       
       describe "StrategySetupMethods" do
         describe "normal strategy definitions" do
           def call_strategy(*args, &block)
-            creator.__send__(strategy_method_name, *args, &block)
+            double_definition_create.__send__(strategy_method_name, *args, &block)
           end
 
           describe "#mock" do
@@ -28,17 +28,15 @@ module RR
               @strategy_method_name = :mock
             end
 
-            send("normal strategy definition")
-
             context "when passing no args" do
               it "returns self" do
-                call_strategy.should === creator
+                call_strategy.should === double_definition_create
               end
             end
 
             context "when passed a subject and a method_name argument" do
               it "creates a mock Double for method" do
-                double_definition = creator.mock(subject, :foobar).returns {:baz}
+                double_definition = double_definition_create.mock(subject, :foobar).returns {:baz}
                 double_definition.times_matcher.should == RR::TimesCalledMatchers::IntegerMatcher.new(1)
                 double_definition.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
                 double_definition.argument_expectation.expected_arguments.should == []
@@ -48,7 +46,7 @@ module RR
 
             context "when already using an ImplementationStrategy" do
               it "raises a DoubleDefinitionError" do
-                creator.mock
+                double_definition_create.mock
                 lambda do
                   call_strategy
                 end.should raise_error(RR::Errors::DoubleDefinitionError, "This Double already has a mock strategy")
@@ -61,17 +59,15 @@ module RR
               @strategy_method_name = :stub
             end
 
-            send("normal strategy definition")
-
             context "when passing no args" do
               it "returns self" do
-                call_strategy.should === creator
+                call_strategy.should === double_definition_create
               end
             end
 
             context "when passed subject and a method_name argument" do
               it "creates a stub Double for method when passed a method_name argument" do
-                double_definition = creator.stub(subject, :foobar).returns {:baz}
+                double_definition = double_definition_create.stub(subject, :foobar).returns {:baz}
                 double_definition.times_matcher.should == RR::TimesCalledMatchers::AnyTimesMatcher.new
                 double_definition.argument_expectation.class.should == RR::Expectations::AnyArgumentExpectation
                 subject.foobar.should == :baz
@@ -80,7 +76,7 @@ module RR
 
             context "when already using an ImplementationStrategy" do
               it "raises a DoubleDefinitionError" do
-                creator.mock
+                double_definition_create.mock
                 lambda do
                   call_strategy
                 end.should raise_error(RR::Errors::DoubleDefinitionError, "This Double already has a mock strategy")
@@ -93,24 +89,22 @@ module RR
               @strategy_method_name = :dont_allow
             end
 
-            send("normal strategy definition")
-
             context "when passing no args" do
               it "returns self" do
-                call_strategy.should === creator
+                call_strategy.should === double_definition_create
               end
             end
 
             it "raises error when proxied" do
-              creator.proxy
+              double_definition_create.proxy
               lambda do
-                creator.dont_allow
+                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 = creator.dont_allow(subject, :foobar)
+                double_definition = double_definition_create.dont_allow(subject, :foobar)
                 double_definition.times_matcher.should == RR::TimesCalledMatchers::NeverMatcher.new
                 double_definition.argument_expectation.class.should == RR::Expectations::AnyArgumentExpectation
 
@@ -123,7 +117,7 @@ module RR
 
             context "when already using an ImplementationStrategy" do
               it "raises a DoubleDefinitionError" do
-                creator.mock
+                double_definition_create.mock
                 lambda do
                   call_strategy
                 end.should raise_error(RR::Errors::DoubleDefinitionError, "This Double already has a mock strategy")
@@ -135,7 +129,7 @@ module RR
         describe "! strategy definitions" do
           attr_reader :strategy_method_name
           def call_strategy(*args, &definition_eval_block)
-            creator.__send__(strategy_method_name, *args, &definition_eval_block)
+            double_definition_create.__send__(strategy_method_name, *args, &definition_eval_block)
           end
 
           describe "#mock!" do
@@ -143,12 +137,11 @@ module RR
               @strategy_method_name = :mock!
             end
 
-            send("! strategy definition")
-
             context "when passed a method_name argument" do
               it "sets #verification_strategy to Mock" do
-                creator.mock!(:foobar)
-                creator.verification_strategy.class.should == Strategies::Verification::Mock
+                double_definition_create.mock!(:foobar)
+                double_definition_create.verification_strategy.class.should == Strategies::Verification::Mock
+                lambda {RR.verify}.should raise_error(::RR::Errors::TimesCalledError)
               end
             end
           end
@@ -158,12 +151,10 @@ module RR
               @strategy_method_name = :stub!
             end
 
-            send("! strategy definition")
-
             context "when passed a method_name argument" do
               it "sets #verification_strategy to Stub" do
-                creator.stub!(:foobar)
-                creator.verification_strategy.class.should == Strategies::Verification::Stub
+                double_definition_create.stub!(:foobar)
+                double_definition_create.verification_strategy.class.should == Strategies::Verification::Stub
               end
             end
           end
@@ -173,12 +164,10 @@ module RR
               @strategy_method_name = :dont_allow!
             end
 
-            send("! strategy definition")
-
             context "when passed a method_name argument" do
               it "sets #verification_strategy to DontAllow" do
-                creator.dont_allow!(:foobar)
-                creator.verification_strategy.class.should == Strategies::Verification::DontAllow
+                double_definition_create.dont_allow!(:foobar)
+                double_definition_create.verification_strategy.class.should == Strategies::Verification::DontAllow
               end
             end
           end
@@ -195,16 +184,16 @@ module RR
 
           context "when already using Strategies::Verification::DontAllow" do
             it "raises error" do
-              creator.dont_allow
+              double_definition_create.dont_allow
               lambda do
-                creator.proxy
+                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 = creator.stub.proxy(subject, :foobar).after_call {:baz}
+              double_definition = double_definition_create.stub.proxy(subject, :foobar).after_call {:baz}
               double_definition.times_matcher.should == RR::TimesCalledMatchers::AnyTimesMatcher.new
               double_definition.argument_expectation.class.should == RR::Expectations::AnyArgumentExpectation
               subject.foobar.should == :baz
@@ -216,7 +205,7 @@ module RR
           context "when not passed a class" do
             it "raises an ArgumentError" do
               lambda do
-                creator.instance_of(Object.new)
+                double_definition_create.instance_of(Object.new)
               end.should raise_error(ArgumentError, "instance_of only accepts class objects")
             end
           end
@@ -224,7 +213,7 @@ module RR
           context "when passed a method_name argument" do
             it "creates a proxy Double for method" do
               klass = Class.new
-              double_definition = creator.stub.instance_of(klass, :foobar).returns {:baz}
+              double_definition = double_definition_create.stub.instance_of(klass, :foobar).returns {:baz}
               double_definition.times_matcher.should == RR::TimesCalledMatchers::AnyTimesMatcher.new
               double_definition.argument_expectation.class.should == RR::Expectations::AnyArgumentExpectation
               klass.new.foobar.should == :baz
@@ -238,8 +227,8 @@ module RR
           end
 
           context "when passed no arguments" do
-            it "returns a DoubleDefinitionCreator" do
-              instance_of.instance_of.should be_instance_of(DoubleDefinitionCreator)
+            it "returns a DoubleDefinitiondouble_definition_create" do
+              instance_of.instance_of.should be_instance_of(DoubleDefinitionCreate)
             end
           end
 
@@ -262,7 +251,7 @@ module RR
           context "when #verification_strategy is not set" do
             it "raises a DoubleDefinitionError" do
               lambda do
-                creator.create(:foobar, 1, 2)
+                double_definition_create.call(:foobar, 1, 2)
               end.should raise_error(RR::Errors::DoubleDefinitionError, "This Double has no strategy")
             end
           end
@@ -270,18 +259,19 @@ module RR
           context "when #verification_strategy is a Mock" do
             context "when #implementation_strategy is a Reimplementation" do
               before do
-                creator.mock(subject)
+                double_definition_create.mock(subject)
               end
 
               it "sets expectation on the #subject that it will be sent the method_name once with the passed-in arguments" do
-                creator.create(:foobar, 1, 2)
+                mock(subject).foobar(1, 2)
                 subject.foobar(1, 2)
                 lambda {subject.foobar(1, 2)}.should raise_error(RR::Errors::TimesCalledError)
+                lambda {RR.verify}.should raise_error(RR::Errors::TimesCalledError)
               end
 
               describe "#subject.method_name being called" do
                 it "returns the return value of the Double#returns block" do
-                  creator.create(:foobar, 1, 2) {:baz}
+                  double_definition_create.call(:foobar, 1, 2) {:baz}
                   subject.foobar(1, 2).should == :baz
                 end
               end
@@ -289,17 +279,19 @@ module RR
 
             context "when #implementation_strategy is a Proxy" do
               before do
-                creator.mock
-                creator.proxy(subject)
+                double_definition_create.mock
+                double_definition_create.proxy(subject)
               end
 
               it "sets expectation on the #subject that it will be sent the method_name once with the passed-in arguments" do
                 def subject.foobar(*args)
-                  :baz;
+                  :baz
                 end
-                creator.create(:foobar, 1, 2)
+                mock(subject).foobar(1, 2)
+                
                 subject.foobar(1, 2)
                 lambda {subject.foobar(1, 2)}.should raise_error(RR::Errors::TimesCalledError)
+                lambda {RR.verify}.should raise_error(RR::Errors::TimesCalledError)
               end
 
               describe "#subject.method_name being called" do
@@ -310,7 +302,7 @@ module RR
                       original_method_called = true
                     end
                   end
-                  creator.create(:foobar, 1, 2)
+                  double_definition_create.call(:foobar, 1, 2)
                   subject.foobar(1, 2)
                   original_method_called.should be_true
                 end
@@ -320,7 +312,7 @@ module RR
                     def subject.foobar(*args)
                       :baz;
                     end
-                    creator.create(:foobar, 1, 2)
+                    double_definition_create.call(:foobar, 1, 2)
                     subject.foobar(1, 2).should == :baz
                   end
                 end
@@ -335,7 +327,7 @@ module RR
                   end
 
                   it "calls the block with the return value of the original method" do
-                    creator.create(:foobar, 1, 2) do |value|
+                    double_definition_create.call(:foobar, 1, 2) do |value|
                       mock(value).a_method {99}
                       value
                     end
@@ -344,7 +336,7 @@ module RR
                   end
 
                   it "returns the return value of the block" do
-                    creator.create(:foobar, 1, 2) do |value|
+                    double_definition_create.call(:foobar, 1, 2) do |value|
                       :something_else
                     end
                     subject.foobar(1, 2).should == :something_else
@@ -357,12 +349,12 @@ module RR
           context "when #verification_strategy is a Stub" do
             context "when #implementation_strategy is a Reimplementation" do
               before do
-                creator.stub(subject)
+                double_definition_create.stub(subject)
               end
 
               context "when not passed a block" do
                 it "returns nil" do
-                  creator.create(:foobar)
+                  double_definition_create.call(:foobar)
                   subject.foobar.should be_nil
                 end
               end
@@ -370,7 +362,7 @@ module RR
               context "when passed a block" do
                 describe "#subject.method_name being called" do
                   it "returns the return value of the block" do
-                    creator.create(:foobar) {:baz}
+                    double_definition_create.call(:foobar) {:baz}
                     subject.foobar.should == :baz
                   end
                 end
@@ -379,7 +371,7 @@ module RR
               context "when not passed args" do
                 describe "#subject.method_name being called with any arguments" do
                   it "invokes the implementation of the Stub" do
-                    creator.create(:foobar) {:baz}
+                    double_definition_create.call(:foobar) {:baz}
                     subject.foobar(1, 2).should == :baz
                     subject.foobar().should == :baz
                     subject.foobar([]).should == :baz
@@ -390,14 +382,14 @@ module RR
               context "when passed args" do
                 describe "#subject.method_name being called with the passed-in arguments" do
                   it "invokes the implementation of the Stub" do
-                    creator.create(:foobar, 1, 2) {:baz}
+                    double_definition_create.call(:foobar, 1, 2) {:baz}
                     subject.foobar(1, 2).should == :baz
                   end
                 end
 
                 describe "#subject.method_name being called with different arguments" do
                   it "raises a DoubleNotFoundError" do
-                    creator.create(:foobar, 1, 2) {:baz}
+                    double_definition_create.call(:foobar, 1, 2) {:baz}
                     lambda do
                       subject.foobar
                     end.should raise_error(RR::Errors::DoubleNotFoundError)
@@ -411,14 +403,14 @@ module RR
                 def subject.foobar(*args)
                   :original_return_value
                 end
-                creator.stub
-                creator.proxy(subject)
+                double_definition_create.stub
+                double_definition_create.proxy(subject)
               end
 
               context "when not passed a block" do
                 describe "#subject.method_name being called" do
                   it "invokes the original implementanion" do
-                    creator.create(:foobar)
+                    double_definition_create.call(:foobar)
                     subject.foobar.should == :original_return_value
                   end
                 end
@@ -428,7 +420,7 @@ module RR
                 describe "#subject.method_name being called" do
                   it "invokes the original implementanion and invokes the block with the return value of the original implementanion" do
                     passed_in_value = nil
-                    creator.create(:foobar) do |original_return_value|
+                    double_definition_create.call(:foobar) do |original_return_value|
                       passed_in_value = original_return_value
                     end
                     subject.foobar
@@ -436,7 +428,7 @@ module RR
                   end
 
                   it "returns the return value of the block" do
-                    creator.create(:foobar) do |original_return_value|
+                    double_definition_create.call(:foobar) do |original_return_value|
                       :new_return_value
                     end
                     subject.foobar.should == :new_return_value
@@ -447,14 +439,14 @@ module RR
               context "when passed args" do
                 describe "#subject.method_name being called with the passed-in arguments" do
                   it "invokes the implementation of the Stub" do
-                    creator.create(:foobar, 1, 2) {:baz}
+                    double_definition_create.call(:foobar, 1, 2) {:baz}
                     subject.foobar(1, 2).should == :baz
                   end
                 end
 
                 describe "#subject.method_name being called with different arguments" do
                   it "raises a DoubleNotFoundError" do
-                    creator.create(:foobar, 1, 2) {:baz}
+                    double_definition_create.call(:foobar, 1, 2) {:baz}
                     lambda do
                       subject.foobar
                     end.should raise_error(RR::Errors::DoubleNotFoundError)
@@ -466,13 +458,13 @@ module RR
 
           context "when #verification_strategy is a DontAllow" do
             before do
-              creator.dont_allow(subject)
+              double_definition_create.dont_allow(subject)
             end
 
             context "when not passed args" do
               describe "#subject.method_name being called with any arguments" do
                 it "raises a TimesCalledError" do
-                  creator.create(:foobar)
+                  double_definition_create.call(:foobar)
                   lambda {subject.foobar}.should raise_error(RR::Errors::TimesCalledError)
                   lambda {subject.foobar(1, 2)}.should raise_error(RR::Errors::TimesCalledError)
                 end
@@ -482,14 +474,14 @@ module RR
             context "when passed args" do
               describe "#subject.method_name being called with the passed-in arguments" do
                 it "raises a TimesCalledError" do
-                  creator.create(:foobar, 1, 2)
+                  double_definition_create.call(:foobar, 1, 2)
                   lambda {subject.foobar(1, 2)}.should raise_error(RR::Errors::TimesCalledError)
                 end
               end
 
               describe "#subject.method_name being called with different arguments" do
                 it "raises a DoubleNotFoundError" do
-                  creator.create(:foobar, 1, 2)
+                  double_definition_create.call(:foobar, 1, 2)
                   lambda {subject.foobar()}.should raise_error(RR::Errors::DoubleNotFoundError)
                 end
               end