rr 0.4.8 → 0.4.9

data/spec/rr/adapters/rr_methods_creator_spec.rb

@@ -15,8 +15,8 @@ module RR
           end
         end
 
-        it "returns a DoubleCreator when passed no arguments" do
-          mock.should be_instance_of(DoubleCreator)
+        it "returns a DoubleDefinitionCreator when passed no arguments" do
+          mock.should be_instance_of(DoubleDefinitionCreator)
         end
 
         it "sets up the RR mock call chain" do
@@ -36,7 +36,7 @@ module RR
         end
 
         it "raises error if passed a method name and a block" do
-          proc do
+          lambda do
             mock(@object, :foobar) {}
           end.should raise_error(ArgumentError, "Cannot pass in a method name and a block")
         end
@@ -72,8 +72,8 @@ module RR
           end
         end
 
-        it "returns a DoubleCreator when passed no arguments" do
-          stub.should be_instance_of(DoubleCreator)
+        it "returns a DoubleDefinitionCreator when passed no arguments" do
+          stub.should be_instance_of(DoubleDefinitionCreator)
         end
 
         it "sets up the RR stub call chain" do
@@ -93,7 +93,7 @@ module RR
         end
 
         it "raises error if passed a method name and a block" do
-          proc do
+          lambda do
             stub(@object, :foobar) {}
           end.should raise_error(ArgumentError, "Cannot pass in a method name and a block")
         end
@@ -125,8 +125,8 @@ module RR
           end
         end
 
-        it "#proxy returns a DoubleCreator when passed no arguments" do
-          proxy.should be_instance_of(DoubleCreator)
+        it "#proxy returns a DoubleDefinitionCreator when passed no arguments" do
+          proxy.should be_instance_of(DoubleDefinitionCreator)
         end
 
         it "#proxy sets up the RR proxy call chain" do
@@ -162,7 +162,7 @@ module RR
         end
 
         it "raises error if passed a method name and a block" do
-          proc do
+          lambda do
             mock.proxy(@object, :foobar) {}
           end.should raise_error(ArgumentError, "Cannot pass in a method name and a block")
         end
@@ -198,8 +198,8 @@ module RR
           end
         end
 
-        it "returns a DoubleCreator when passed no arguments" do
-          stub.proxy.should be_instance_of(DoubleCreator)
+        it "returns a DoubleDefinitionCreator when passed no arguments" do
+          stub.proxy.should be_instance_of(DoubleDefinitionCreator)
         end
 
         it "sets up the RR proxy call chain" do
@@ -219,7 +219,7 @@ module RR
         end
 
         it "raises error if passed a method name and a block" do
-          proc do
+          lambda do
             stub.proxy(@object, :foobar) {}
           end.should raise_error(ArgumentError, "Cannot pass in a method name and a block")
         end
@@ -252,8 +252,8 @@ module RR
           end
         end
 
-        it "returns a DoubleCreator when passed no arguments" do
-          do_not_allow.should be_instance_of(DoubleCreator)
+        it "returns a DoubleDefinitionCreator when passed no arguments" do
+          do_not_allow.should be_instance_of(DoubleDefinitionCreator)
         end
 
         it "sets up the RR do_not_allow call chain" do
@@ -279,7 +279,7 @@ module RR
         end
 
         it "raises error if passed a method name and a block" do
-          proc do
+          lambda do
             do_not_allow(@object, :foobar) {}
           end.should raise_error(ArgumentError, "Cannot pass in a method name and a block")
         end
@@ -290,7 +290,7 @@ module RR
           double.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
           double.argument_expectation.expected_arguments.should == [1, 2]
 
-          proc do
+          lambda do
             @subject.foobar(1, 2)
           end.should raise_error(Errors::TimesCalledError)
           reset
@@ -303,7 +303,7 @@ module RR
           double.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
           double.argument_expectation.expected_arguments.should == [1, 2]
 
-          proc do
+          lambda do
             @subject.foobar(1, 2)
           end.should raise_error(Errors::TimesCalledError)
           reset
@@ -311,13 +311,13 @@ module RR
         end
       end
 
-      describe DoubleCreator, "#instance_of and #mock" do
+      describe DoubleDefinitionCreator, "#instance_of and #mock" do
         before do
           @klass = Class.new
         end
 
-        it "returns a DoubleCreator when passed no arguments" do
-          instance_of.instance_of.should be_instance_of(DoubleCreator)
+        it "returns a DoubleDefinitionCreator when passed no arguments" do
+          instance_of.instance_of.should be_instance_of(DoubleDefinitionCreator)
         end
 
         it "sets up the RR instance_of call chain" do
@@ -337,7 +337,7 @@ module RR
         end
 
         it "raises error if passed a method name and a block" do
-          proc do
+          lambda do
             instance_of.mock(@klass, :foobar) {}
           end.should raise_error(ArgumentError, "Cannot pass in a method name and a block")
         end

data/spec/rr/adapters/rr_methods_space_spec.rb

@@ -87,8 +87,8 @@ module RR
             double1 = @space.double_injection(@object1, :foobar1)
             double2 = @space.double_injection(@object1, :foobar2)
 
-            double1 = @space.double(double1)
-            double2 = @space.double(double2)
+            double1 = Double.new(double1)
+            double2 = Double.new(double2)
 
             double1.ordered
             double2.ordered

data/spec/rr/double/double_injection_dispatching_spec.rb

@@ -22,7 +22,7 @@ module RR
               yield(a, b)
             end
           end
-          double = @space.double(@double_injection)
+          double = Double.new(@double_injection)
           double.with(1, 2).implemented_by(method_fixture.method(:method_with_block))
           @object.foobar(1, 2) {|a, b| [b, a]}.should == [2, 1]
         end
@@ -30,11 +30,11 @@ module RR
 
       describe "where there are no doubles with duplicate ArgumentExpectations" do
         it "dispatches to Double that have an exact match" do
-          double1_with_exact_match = @space.double(@double_injection)
+          double1_with_exact_match = Double.new(@double_injection)
           double1_with_exact_match.with(:exact_match_1).returns {:return_1}
-          double_with_no_match = @space.double(@double_injection)
+          double_with_no_match = Double.new(@double_injection)
           double_with_no_match.with("nothing that matches").returns {:no_match}
-          double2_with_exact_match = @space.double(@double_injection)
+          double2_with_exact_match = Double.new(@double_injection)
           double2_with_exact_match.with(:exact_match_2).returns {:return_2}
 
           @object.foobar(:exact_match_1).should == :return_1
@@ -42,9 +42,9 @@ module RR
         end
 
         it "dispatches to Double that have a wildcard match" do
-          double_with_wildcard_match = @space.double(@double_injection)
+          double_with_wildcard_match = Double.new(@double_injection)
           double_with_wildcard_match.with_any_args.returns {:wild_card_value}
-          double_with_no_match = @space.double(@double_injection)
+          double_with_no_match = Double.new(@double_injection)
           double_with_no_match.with("nothing that matches").returns {:no_match}
 
           @object.foobar(:wildcard_match_1).should == :wild_card_value
@@ -54,10 +54,10 @@ module RR
 
       describe "where there are doubles" do
         it "raises DoubleNotFoundError error when arguments do not match a double" do
-          double_1 = @space.double(@double_injection)
+          double_1 = Double.new(@double_injection)
           double_1.with(1, 2)
 
-          double_2 = @space.double(@double_injection)
+          double_2 = Double.new(@double_injection)
           double_2.with(3)
 
           error = nil
@@ -109,7 +109,7 @@ module RR
         end
 
         def double(*arguments, &return_value)
-          double = @space.double(@double_injection)
+          double = Double.new(@double_injection)
           double.with(*arguments).any_number_of_times.returns(&return_value)
           double.should_not be_terminal
           double
@@ -145,13 +145,13 @@ module RR
 
           @object.foobar(:exact_match)
           @object.foobar(:exact_match)
-          proc do
+          lambda do
             @object.foobar(:exact_match)
           end.should raise_error(Errors::TimesCalledError)
         end
 
         def double(*arguments, &return_value)
-          double = @space.double(@double_injection)
+          double = Double.new(@double_injection)
           double.with(*arguments).once.returns(&return_value)
           double.should be_terminal
           double
@@ -187,13 +187,13 @@ module RR
 
           @object.foobar(:anything)
           @object.foobar(:anything)
-          proc do
+          lambda do
             @object.foobar(:anything)
           end.should raise_error(Errors::TimesCalledError)
         end
 
         def double(&return_value)
-          double = @space.double(@double_injection)
+          double = Double.new(@double_injection)
           double.with_any_args.once.returns(&return_value)
           double.should be_terminal
           double
@@ -207,7 +207,7 @@ module RR
       end
 
       it "executes the block" do
-        double = @space.double(@double_injection)
+        double = Double.new(@double_injection)
         double.with(1, 2) {:return_value}
         @object.foobar!(1, 2).should == :return_value
       end
@@ -219,7 +219,7 @@ module RR
       end
 
       it "executes the block" do
-        double = @space.double(@double_injection)
+        double = Double.new(@double_injection)
         double.with(1, 2) {:return_value}
         @object.foobar?(1, 2).should == :return_value
       end

data/spec/rr/double/double_injection_reset_spec.rb

@@ -27,7 +27,7 @@ module RR
 
       @double_injection.reset
       @object.methods.should_not include(@method_name.to_s)
-      proc {@object.foobar}.should raise_error(NoMethodError)
+      lambda {@object.foobar}.should raise_error(NoMethodError)
     end
   end
 

data/spec/rr/double/double_injection_verify_spec.rb

@@ -2,8 +2,9 @@ require "spec/spec_helper"
 
 module RR
   describe DoubleInjection, "#verify" do
+    it_should_behave_like "Swapped Space"
     before do
-      @space = Space.new
+      @space = Space.instance
       @object = Object.new
       @method_name = :foobar
       @object.methods.should_not include(@method_name.to_s)
@@ -11,13 +12,13 @@ module RR
     end
 
     it "verifies each double was met" do
-      double = Double.new(@space, @double_injection, @space.double_definition)
+      double = Double.new(@double_injection, DoubleDefinition.new)
       @double_injection.register_double double
 
       double.with(1).once.returns {nil}
-      proc {@double_injection.verify}.should raise_error(Errors::TimesCalledError)
+      lambda {@double_injection.verify}.should raise_error(Errors::TimesCalledError)
       @object.foobar(1)
-      proc {@double_injection.verify}.should_not raise_error
+      lambda {@double_injection.verify}.should_not raise_error
     end
   end
 end

data/spec/rr/{double_method_proxy_spec.rb → double_definition_creator_proxy_spec.rb}

@@ -1,7 +1,7 @@
 require "spec/spec_helper"
 
 module RR
-  describe DoubleMethodProxy, "initializes proxy with passed in creator", :shared => true do
+  describe DoubleDefinitionCreatorProxy, "initializes proxy with passed in creator", :shared => true do
     it "initializes proxy with passed in creator" do
       class << the_proxy
         attr_reader :creator
@@ -10,23 +10,25 @@ module RR
     end
   end
 
-  describe DoubleMethodProxy do
+  describe DoubleDefinitionCreatorProxy do
     attr_reader :space, :subject, :creator, :the_proxy
+    it_should_behave_like "Swapped Space"
+
     before(:each) do
-      @space = Space.new
+      @space = Space.instance
       @subject = Object.new
-      @creator = space.double_creator
+      @creator = DoubleDefinitionCreator.new
       creator.mock
     end
 
     describe ".new without block" do
-      it_should_behave_like "RR::DoubleMethodProxy initializes proxy with passed in creator"
+      it_should_behave_like "RR::DoubleDefinitionCreatorProxy initializes proxy with passed in creator"
       before do
-        @the_proxy = DoubleMethodProxy.new(creator, subject)
+        @the_proxy = DoubleDefinitionCreatorProxy.new(creator, subject)
       end
 
       it "clears out all methods from proxy" do
-        proxy_subclass = Class.new(DoubleMethodProxy) do
+        proxy_subclass = Class.new(DoubleDefinitionCreatorProxy) do
           def i_should_be_a_double
           end
         end
@@ -38,9 +40,9 @@ module RR
     end
 
     describe ".new with block" do
-      it_should_behave_like "RR::DoubleMethodProxy initializes proxy with passed in creator"
+      it_should_behave_like "RR::DoubleDefinitionCreatorProxy initializes proxy with passed in creator"
       before do
-        @the_proxy = DoubleMethodProxy.new(creator, subject) do |b|
+        @the_proxy = DoubleDefinitionCreatorProxy.new(creator, subject) do |b|
           b.foobar(1, 2) {:one_two}
           b.foobar(1) {:one}
           b.foobar.with_any_args {:default}
@@ -56,7 +58,7 @@ module RR
       end
 
       it "clears out all methods from proxy" do
-        proxy_subclass = Class.new(DoubleMethodProxy) do
+        proxy_subclass = Class.new(DoubleDefinitionCreatorProxy) do
           def i_should_be_a_double
           end
         end

data/spec/rr/{double_creator_spec.rb → double_definition_creator_spec.rb}

@@ -1,30 +1,30 @@
 require "spec/spec_helper"
 
 module RR
-  describe DoubleCreator, " strategy definition", :shared => true do
+  describe DoubleDefinitionCreator, " strategy definition", :shared => true do
     it "returns self when passing no args" do
       creator.__send__(method_name).should === creator
     end
 
-    it "returns a DoubleMethodProxy when passed a subject" do
+    it "returns a DoubleDefinitionCreatorProxy when passed a subject" do
       double = creator.__send__(method_name, subject).foobar
       double.should be_instance_of(DoubleDefinition)
     end
 
-    it "returns a DoubleMethodProxy when passed Kernel" do
+    it "returns a DoubleDefinitionCreatorProxy when passed Kernel" do
       double = creator.__send__(method_name, Kernel).foobar
       double.should be_instance_of(DoubleDefinition)
     end
 
     it "raises error if passed a method name and a block" do
-      proc do
+      lambda do
         creator.__send__(method_name, subject, :foobar) {}
       end.should raise_error(ArgumentError, "Cannot pass in a method name and a block")
     end
 
     it "raises error when using mock strategy" do
       creator.mock
-      proc do
+      lambda do
         creator.__send__(method_name)
       end.should raise_error(
       Errors::DoubleDefinitionError,
@@ -34,7 +34,7 @@ module RR
 
     it "raises error when using stub strategy" do
       creator.stub
-      proc do
+      lambda do
         creator.__send__(method_name)
       end.should raise_error(
       Errors::DoubleDefinitionError,
@@ -44,25 +44,26 @@ module RR
 
     it "raises error when using dont_allow strategy" do
       creator.dont_allow
-      proc do
+      lambda do
         creator.__send__(method_name)
       end.should raise_error(
-      Errors::DoubleDefinitionError,
-      "This Double already has a dont_allow strategy"
+        Errors::DoubleDefinitionError,
+        "This Double already has a dont_allow strategy"
       )
     end
   end
 
-  describe DoubleCreator do
+  describe DoubleDefinitionCreator do
     attr_reader :creator, :subject, :space, :method_name
+    it_should_behave_like "Swapped Space"
     before(:each) do
-      @space = Space.new
+      @space = Space.instance
       @subject = Object.new
-      @creator = DoubleCreator.new(space)
+      @creator = DoubleDefinitionCreator.new
     end
 
     describe "#mock" do
-      it_should_behave_like "RR::DoubleCreator strategy definition"
+      it_should_behave_like "RR::DoubleDefinitionCreator strategy definition"
 
       before do
         @method_name = :mock
@@ -72,19 +73,13 @@ module RR
         creates_mock_call_chain(creator.mock(subject))
       end
 
-      it "creates a mock Double for method when passed a second argument with rr_mock" do
-        creates_double_with_method_name(
-        creator.mock(subject, :foobar)
-        )
-      end
-
       it "sets up the DoubleDefinition to be in returns block_callback_strategy" do
         double = creator.mock(subject, :foobar)
         double.block_callback_strategy.should == :returns
       end
 
-      def creates_double_with_method_name(double)
-        double.with(1, 2) {:baz}
+      def creates_mock_call_chain(creator)
+        double = creator.foobar(1, 2) {:baz}
         double.times_matcher.should == TimesCalledMatchers::IntegerMatcher.new(1)
         double.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
         double.argument_expectation.expected_arguments.should == [1, 2]
@@ -92,18 +87,32 @@ module RR
         subject.foobar(1, 2).should == :baz
       end
 
-      def creates_mock_call_chain(creator)
-        double = creator.foobar(1, 2) {:baz}
-        double.times_matcher.should == TimesCalledMatchers::IntegerMatcher.new(1)
-        double.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
-        double.argument_expectation.expected_arguments.should == [1, 2]
+      context "when passed a second argument" do
+        it "creates a mock Double for method" do
+          creates_double_with_method_name( creator.mock(subject, :foobar) )
+        end
 
-        subject.foobar(1, 2).should == :baz
+        def creates_double_with_method_name(double)
+          double.with(1, 2) {:baz}
+          double.times_matcher.should == TimesCalledMatchers::IntegerMatcher.new(1)
+          double.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
+          double.argument_expectation.expected_arguments.should == [1, 2]
+
+          subject.foobar(1, 2).should == :baz
+        end
+      end
+
+      context "when passed method_name and block" do
+        it "raises error" do
+          lambda do
+            @creator.mock(@object, :foobar) {}
+          end.should raise_error(ArgumentError, "Cannot pass in a method name and a block")
+        end
       end
     end
 
     describe "#stub" do
-      it_should_behave_like "RR::DoubleCreator strategy definition"
+      it_should_behave_like "RR::DoubleDefinitionCreator strategy definition"
 
       before do
         @method_name = :stub
@@ -113,20 +122,22 @@ module RR
         creates_stub_call_chain(creator.stub(subject))
       end
 
-      it "creates a stub Double for method when passed a second argument" do
-        creates_double_with_method_name(creator.stub(subject, :foobar))
-      end
-
       it "sets up the DoubleDefinition to be in returns block_callback_strategy" do
         double = creator.stub(subject, :foobar)
         double.block_callback_strategy.should == :returns
       end
 
-      def creates_double_with_method_name(double)
-        double.with(1, 2) {:baz}
-        double.times_matcher.should == TimesCalledMatchers::AnyTimesMatcher.new
-        double.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
-        subject.foobar(1, 2).should == :baz
+      context "when passed a second argument" do
+        it "creates a stub Double for method when passed a second argument" do
+          creates_double_with_method_name(creator.stub(subject, :foobar))
+        end
+
+        def creates_double_with_method_name(double)
+          double.with(1, 2) {:baz}
+          double.times_matcher.should == TimesCalledMatchers::AnyTimesMatcher.new
+          double.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
+          subject.foobar(1, 2).should == :baz
+        end
       end
 
       def creates_stub_call_chain(creator)
@@ -135,10 +146,18 @@ module RR
         double.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
         subject.foobar(1, 2).should == :baz
       end
+
+      context "when passed method_name and block" do
+        it "raises error" do
+          lambda do
+            @creator.stub(@object, :foobar) {}
+          end.should raise_error(ArgumentError, "Cannot pass in a method name and a block")
+        end
+      end
     end
 
     describe "#dont_allow" do
-      it_should_behave_like "RR::DoubleCreator strategy definition"
+      it_should_behave_like "RR::DoubleDefinitionCreator strategy definition"
 
       before do
         @method_name = :dont_allow
@@ -146,7 +165,7 @@ module RR
 
       it "raises error when proxied" do
         creator.proxy
-        proc do
+        lambda do
           creator.dont_allow
         end.should raise_error(
         Errors::DoubleDefinitionError,
@@ -170,33 +189,35 @@ module RR
         creates_dont_allow_call_chain(creator.dont_allow(subject))
       end
 
-      it "creates a mock Double for method when passed a second argument" do
-        creates_double_with_method_name(creator.dont_allow(subject, :foobar))
-      end
-
-      it "creates a mock Double for method when passed a second argument" do
-        creates_double_with_method_name(creator.dont_call(subject, :foobar))
-      end
+      context "when passed a second argument_expectation" do
+        it "creates a mock Double for method" do
+          creates_double_with_method_name(creator.dont_allow(subject, :foobar))
+        end
 
-      it "creates a mock Double for method when passed a second argument" do
-        creates_double_with_method_name(creator.do_not_allow(subject, :foobar))
-      end
+        it "creates a mock Double for method" do
+          creates_double_with_method_name(creator.dont_call(subject, :foobar))
+        end
 
-      it "creates a mock Double for method when passed a second argument" do
-        creates_double_with_method_name(creator.dont_allow(subject, :foobar))
-      end
+        it "creates a mock Double for method" do
+          creates_double_with_method_name(creator.do_not_allow(subject, :foobar))
+        end
 
-      def creates_double_with_method_name(double)
-        double.with(1, 2)
-        double.times_matcher.should == TimesCalledMatchers::IntegerMatcher.new(0)
-        double.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
-        double.argument_expectation.expected_arguments.should == [1, 2]
+        it "creates a mock Double for method" do
+          creates_double_with_method_name(creator.dont_allow(subject, :foobar))
+        end
 
-        proc do
-          subject.foobar(1, 2)
-        end.should raise_error(Errors::TimesCalledError)
-        reset
-        nil
+        def creates_double_with_method_name(double)
+          double.with(1, 2)
+          double.times_matcher.should == TimesCalledMatchers::IntegerMatcher.new(0)
+          double.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
+          double.argument_expectation.expected_arguments.should == [1, 2]
+
+          lambda do
+            subject.foobar(1, 2)
+          end.should raise_error(Errors::TimesCalledError)
+          reset
+          nil
+        end
       end
 
       def creates_dont_allow_call_chain(creator)
@@ -205,12 +226,20 @@ module RR
         double.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
         double.argument_expectation.expected_arguments.should == [1, 2]
 
-        proc do
+        lambda do
           subject.foobar(1, 2)
         end.should raise_error(Errors::TimesCalledError)
         reset
         nil
       end
+
+      context "when passed method_name and block" do
+        it "raises error" do
+          lambda do
+            @creator.dont_allow(@object, :foobar) {}
+          end.should raise_error(ArgumentError, "Cannot pass in a method name and a block")
+        end
+      end
     end
 
     describe "(#proxy or #proxy) and #stub" do
@@ -224,7 +253,7 @@ module RR
 
       it "raises error when using dont_allow strategy" do
         creator.dont_allow
-        proc do
+        lambda do
           creator.proxy
         end.should raise_error(
         Errors::DoubleDefinitionError,
@@ -246,20 +275,22 @@ module RR
         subject.foobar(1, 2).should == :baz
       end
 
-      it "creates a proxy Double for method when passed a second argument" do
-        double = creator.stub.proxy(subject, :foobar)
-        double.with(1, 2) {:baz}
-        double.times_matcher.should == TimesCalledMatchers::AnyTimesMatcher.new
-        double.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
-        subject.foobar(1, 2).should == :baz
-      end
+      context "when passed a second argument" do
+        it "creates a proxy Double for method" do
+          double = creator.stub.proxy(subject, :foobar)
+          double.with(1, 2) {:baz}
+          double.times_matcher.should == TimesCalledMatchers::AnyTimesMatcher.new
+          double.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
+          subject.foobar(1, 2).should == :baz
+        end
 
-      it "creates a proxy Double for method when passed a second argument" do
-        double = creator.stub.proxy(subject, :foobar)
-        double.with(1, 2) {:baz}
-        double.times_matcher.should == TimesCalledMatchers::AnyTimesMatcher.new
-        double.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
-        subject.foobar(1, 2).should == :baz
+        it "creates a proxy Double for method" do
+          double = creator.stub.proxy(subject, :foobar)
+          double.with(1, 2) {:baz}
+          double.times_matcher.should == TimesCalledMatchers::AnyTimesMatcher.new
+          double.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
+          subject.foobar(1, 2).should == :baz
+        end
       end
 
       it "sets up the DoubleDefinition to be in after_call block_callback_strategy" do
@@ -275,11 +306,19 @@ module RR
         args.should == [:original_implementation_value]
         double.block_callback_strategy.should == :after_call
       end
+
+      context "when passed method_name and block" do
+        it "raises error" do
+          lambda do
+            @creator.proxy(@object, :foobar) {}
+          end.should raise_error(ArgumentError, "Cannot pass in a method name and a block")
+        end
+      end
     end
 
     describe "#instance_of" do
       it "raises an error when not passed a class" do
-        proc do
+        lambda do
           creator.instance_of(Object.new)
         end.should raise_error(ArgumentError, "instance_of only accepts class objects")
       end
@@ -292,20 +331,29 @@ module RR
         klass.new.foobar(1, 2).should == :baz
       end
 
-      it "creates a proxy Double for method when passed a second argument" do
+      context "when passed a second argument" do
+        it "creates a proxy Double for method" do
+          klass = Class.new
+          double = creator.stub.instance_of(klass, :foobar)
+          double.with(1, 2) {:baz}
+          double.times_matcher.should == TimesCalledMatchers::AnyTimesMatcher.new
+          double.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
+          klass.new.foobar(1, 2).should == :baz
+        end
+      end
+
+      it "raises error" do
         klass = Class.new
-        double = creator.stub.instance_of(klass, :foobar)
-        double.with(1, 2) {:baz}
-        double.times_matcher.should == TimesCalledMatchers::AnyTimesMatcher.new
-        double.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
-        klass.new.foobar(1, 2).should == :baz
+        lambda do
+          @creator.instance_of(klass, :foobar) {}
+        end.should raise_error(ArgumentError, "Cannot pass in a method name and a block")
       end
     end
 
-    describe "#create! using no strategy" do
+    describe "#create using no strategy" do
       it "raises error" do
-        proc do
-          creator.create!(subject, :foobar, 1, 2)
+        lambda do
+          creator.create(subject, :foobar, 1, 2)
         end.should raise_error(
         Errors::DoubleDefinitionError,
         "This Double has no strategy"
@@ -313,65 +361,65 @@ module RR
       end
     end
 
-    describe "#create! using mock strategy" do
+    describe "#create using mock strategy" do
       before do
         creator.mock
       end
 
       it "sets expectations on the subject" do
-        creator.create!(subject, :foobar, 1, 2) {:baz}.twice
+        creator.create(subject, :foobar, 1, 2) {:baz}.twice
 
         subject.foobar(1, 2).should == :baz
         subject.foobar(1, 2).should == :baz
-        proc {subject.foobar(1, 2)}.should raise_error(Errors::TimesCalledError)
+        lambda {subject.foobar(1, 2)}.should raise_error(Errors::TimesCalledError)
       end
     end
 
-    describe "#create! using stub strategy" do
+    describe "#create using stub strategy" do
       before do
         creator.stub
       end
 
       it "stubs the subject without any args" do
-        creator.create!(subject, :foobar) {:baz}
+        creator.create(subject, :foobar) {:baz}
         subject.foobar.should == :baz
       end
 
       it "stubs the subject mapping passed in args with the output" do
-        creator.create!(subject, :foobar, 1, 2) {:one_two}
-        creator.create!(subject, :foobar, 1) {:one}
-        creator.create!(subject, :foobar) {:nothing}
+        creator.create(subject, :foobar, 1, 2) {:one_two}
+        creator.create(subject, :foobar, 1) {:one}
+        creator.create(subject, :foobar) {:nothing}
         subject.foobar.should == :nothing
         subject.foobar(1).should == :one
         subject.foobar(1, 2).should == :one_two
       end
     end
 
-    describe "#create! using dont_allow strategy" do
+    describe "#create using dont_allow strategy" do
       before do
         creator.dont_allow
       end
 
       it "sets expectation for method to never be called with any arguments when on arguments passed in" do
-        creator.create!(subject, :foobar)
-        proc {subject.foobar}.should raise_error(Errors::TimesCalledError)
-        proc {subject.foobar(1, 2)}.should raise_error(Errors::TimesCalledError)
+        creator.create(subject, :foobar)
+        lambda {subject.foobar}.should raise_error(Errors::TimesCalledError)
+        lambda {subject.foobar(1, 2)}.should raise_error(Errors::TimesCalledError)
       end
 
       it "sets expectation for method to never be called with passed in arguments" do
-        creator.create!(subject, :foobar, 1, 2)
-        proc {subject.foobar}.should raise_error(Errors::DoubleNotFoundError)
-        proc {subject.foobar(1, 2)}.should raise_error(Errors::TimesCalledError)
+        creator.create(subject, :foobar, 1, 2)
+        lambda {subject.foobar}.should raise_error(Errors::DoubleNotFoundError)
+        lambda {subject.foobar(1, 2)}.should raise_error(Errors::TimesCalledError)
       end
 
       it "sets expectation for method to never be called with no arguments when with_no_args is set" do
-        creator.create!(subject, :foobar).with_no_args
-        proc {subject.foobar}.should raise_error(Errors::TimesCalledError)
-        proc {subject.foobar(1, 2)}.should raise_error(Errors::DoubleNotFoundError)
+        creator.create(subject, :foobar).with_no_args
+        lambda {subject.foobar}.should raise_error(Errors::TimesCalledError)
+        lambda {subject.foobar(1, 2)}.should raise_error(Errors::DoubleNotFoundError)
       end
     end
 
-    describe "#create! using mock strategy with proxy" do
+    describe "#create using mock strategy with proxy" do
       before do
         creator.mock
         creator.proxy
@@ -381,21 +429,18 @@ module RR
         def subject.foobar(*args)
           ; :baz;
         end
-        creator.create!(subject, :foobar, 1, 2).twice
+        creator.create(subject, :foobar, 1, 2).twice
         subject.foobar(1, 2).should == :baz
         subject.foobar(1, 2).should == :baz
-        proc {subject.foobar(1, 2)}.should raise_error(Errors::TimesCalledError)
+        lambda {subject.foobar(1, 2)}.should raise_error(Errors::TimesCalledError)
       end
 
       it "sets after_call on the double when passed a block" do
         real_value = Object.new
-        (
-        class << subject;
-          self;
-        end).class_eval do
+        (class << subject; self; end).class_eval do
           define_method(:foobar) {real_value}
         end
-        creator.create!(subject, :foobar, 1, 2) do |value|
+        creator.create(subject, :foobar, 1, 2) do |value|
           mock(value).a_method {99}
           value
         end
@@ -406,7 +451,7 @@ module RR
       end
     end
 
-    describe "#create! using stub strategy with proxy" do
+    describe "#create using stub strategy with proxy" do
       before do
         creator.stub
         creator.proxy
@@ -414,19 +459,19 @@ module RR
 
       it "sets up a double with passed in arguments" do
         def subject.foobar(*args)
-          ; :baz;
+          :baz
         end
-        creator.create!(subject, :foobar, 1, 2)
-        proc do
+        creator.create(subject, :foobar, 1, 2)
+        lambda do
           subject.foobar
         end.should raise_error(Errors::DoubleNotFoundError)
       end
 
       it "sets expectations on the subject while calling the original method" do
         def subject.foobar(*args)
-          ; :baz;
+          :baz
         end
-        creator.create!(subject, :foobar, 1, 2) {:new_value}
+        creator.create(subject, :foobar, 1, 2) {:new_value}
         10.times do
           subject.foobar(1, 2).should == :new_value
         end
@@ -434,13 +479,10 @@ module RR
 
       it "sets after_call on the double when passed a block" do
         real_value = Object.new
-        (
-        class << subject;
-          self;
-        end).class_eval do
+        (class << subject; self; end).class_eval do
           define_method(:foobar) {real_value}
         end
-        creator.create!(subject, :foobar, 1, 2) do |value|
+        creator.create(subject, :foobar, 1, 2) do |value|
           mock(value).a_method {99}
           value
         end