rr 0.2.4 → 0.2.5

data/CHANGES

@@ -1,3 +1,12 @@
+* 0.2.5
+- mock takes method_name argument
+- stub takes method_name argument
+- mock_probe takes method_name argument
+- stub_probe takes method_name argument
+- probe takes method_name argument
+- dont_allow takes method_name argument
+- do_not_allow takes method_name argument
+
 * 0.2.4
 - Space#doubles key is now the object id
 - Fixed [#12402] Stubbing return value of probes fails after calling the stubbed method two times

data/Rakefile

@@ -21,7 +21,7 @@ def run_suite
 end
 
 PKG_NAME = "rr"
-PKG_VERSION = "0.2.4"
+PKG_VERSION = "0.2.5"
 PKG_FILES = FileList[
   '[A-Z]*',
   '*.rb',

data/examples/rr/extensions/instance_methods_creator_example.rb

@@ -7,23 +7,46 @@ module Extensions
 
     before do
       @subject = Object.new
+      class << @subject
+        def foobar(*args)
+          :original_value
+        end
+      end
     end
 
     it "sets up the RR mock call chain" do
-      should_create_mock_call_chain mock(@subject)
+      should create_mock_call_chain(mock(@subject))
     end
 
-    it "sets up the RR mock call chain with rr_mock" do
-      should_create_mock_call_chain rr_mock(@subject)
+    it "#rr_mock sets up the RR mock call chain" do
+      should create_mock_call_chain(rr_mock(@subject))
     end
 
-    def should_create_mock_call_chain(creator)
-      class << @subject
-        def foobar(*args)
-          :original_value
-        end
-      end
+    it "creates a mock Scenario for method when passed a second argument" do
+      should create_scenario_with_method_name(mock(@subject, :foobar))
+    end
 
+    it "creates a mock Scenario for method when passed a second argument with rr_mock" do
+      should create_scenario_with_method_name(rr_mock(@subject, :foobar))
+    end
+
+    it "raises error if passed a method name and a block" do
+      proc do
+        mock(@object, :foobar) {}
+      end.should raise_error(ArgumentError, "Cannot pass in a method name and a block")
+    end
+    
+    def create_scenario_with_method_name(scenario)
+      method_name = scenario.method_name
+      scenario.with(1, 2) {:baz}
+      scenario.times_matcher.should == TimesCalledMatchers::IntegerMatcher.new(1)
+      scenario.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
+      scenario.argument_expectation.expected_arguments.should == [1, 2]
+
+      @subject.__send__(method_name, 1, 2).should == :baz
+    end
+
+    def create_mock_call_chain(creator)
       scenario = creator.foobar(1, 2) {:baz}
       scenario.times_matcher.should == TimesCalledMatchers::IntegerMatcher.new(1)
       scenario.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
@@ -38,23 +61,44 @@ module Extensions
 
     before do
       @subject = Object.new
+      class << @subject
+        def foobar(*args)
+          :original_value
+        end
+      end
     end
 
     it "sets up the RR stub call chain" do
-      should_create_stub_call_chain stub(@subject)
+      should create_stub_call_chain(stub(@subject))
     end
 
-    it "sets up the RR stub call chain with rr_stub" do
-      should_create_stub_call_chain rr_stub(@subject)
+    it "#rr_stub sets up the RR stub call chain" do
+      should create_stub_call_chain(rr_stub(@subject))
     end
 
-    def should_create_stub_call_chain(creator)
-      class << @subject
-        def foobar(*args)
-          :original_value
-        end
-      end
+    it "creates a stub Scenario for method when passed a second argument" do
+      should create_scenario_with_method_name(stub(@subject, :foobar))
+    end
+
+    it "#rr_stub creates a stub Scenario for method when passed a second argument" do
+      should create_scenario_with_method_name(rr_stub(@subject, :foobar))
+    end
+
+    it "raises error if passed a method name and a block" do
+      proc do
+        stub(@object, :foobar) {}
+      end.should raise_error(ArgumentError, "Cannot pass in a method name and a block")
+    end
 
+    def create_scenario_with_method_name(scenario)
+      method_name = scenario.method_name
+      scenario.with(1, 2) {:baz}
+      scenario.times_matcher.should == TimesCalledMatchers::AnyTimesMatcher.new
+      scenario.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
+      @subject.__send__(method_name, 1, 2).should == :baz
+    end
+
+    def create_stub_call_chain(creator)
       scenario = creator.foobar(1, 2) {:baz}
       scenario.times_matcher.should == TimesCalledMatchers::AnyTimesMatcher.new
       scenario.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
@@ -67,27 +111,62 @@ module Extensions
 
     before do
       @subject = Object.new
+      class << @subject
+        def foobar(*args)
+          :original_value
+        end
+      end      
     end
 
-    it "sets up the RR probe call chain" do
-      should_create_mock_probe_call_chain probe(@subject)
+    it "#probe sets up the RR probe call chain" do
+      should create_mock_probe_call_chain(probe(@subject))
     end
 
-    it "sets up the RR probe call chain" do
-      should_create_mock_probe_call_chain mock_probe(@subject)
+    it "#rr_probe sets up the RR probe call chain" do
+      should create_mock_probe_call_chain(rr_probe(@subject))
     end
 
-    it "sets up the RR probe call chain with rr_probe" do
-      should_create_mock_probe_call_chain rr_mock_probe(@subject)
+    it "#mock_probe sets up the RR probe call chain" do
+      should create_mock_probe_call_chain(mock_probe(@subject))
     end
 
-    def should_create_mock_probe_call_chain(creator)
-      class << @subject
-        def foobar(*args)
-          :original_value
-        end
-      end
+    it "#rr_mock_probe sets up the RR probe call chain with rr_probe" do
+      should create_mock_probe_call_chain(rr_mock_probe(@subject))
+    end
+
+    it "#probe creates a mock Scenario for method when passed a second argument" do
+      should create_scenario_with_method_name(probe(@subject, :foobar))
+    end
+
+    it "#rr_probe creates a mock Scenario for method when passed a second argument with rr_mock" do
+      should create_scenario_with_method_name(rr_probe(@subject, :foobar))
+    end
+
+    it "#mock_probe creates a mock Scenario for method when passed a second argument" do
+      should create_scenario_with_method_name(mock_probe(@subject, :foobar))
+    end
 
+    it "#rr_mock_probe creates a mock Scenario for method when passed a second argument with rr_mock" do
+      should create_scenario_with_method_name(rr_mock_probe(@subject, :foobar))
+    end
+
+    it "raises error if passed a method name and a block" do
+      proc do
+        mock_probe(@object, :foobar) {}
+      end.should raise_error(ArgumentError, "Cannot pass in a method name and a block")
+    end
+
+    def create_scenario_with_method_name(scenario)
+      method_name = scenario.method_name
+      scenario.with(1, 2)
+      scenario.times_matcher.should == TimesCalledMatchers::IntegerMatcher.new(1)
+      scenario.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
+      scenario.argument_expectation.expected_arguments.should == [1, 2]
+
+      @subject.__send__(method_name, 1, 2).should == :original_value
+    end
+
+    def create_mock_probe_call_chain(creator)
       scenario = creator.foobar(1, 2)
       scenario.times_matcher.should == TimesCalledMatchers::IntegerMatcher.new(1)
       scenario.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
@@ -102,23 +181,44 @@ module Extensions
 
     before do
       @subject = Object.new
+      class << @subject
+        def foobar(*args)
+          :original_value
+        end
+      end
     end
 
     it "sets up the RR probe call chain" do
-      should_create_stub_probe_call_chain stub_probe(@subject)
+      should create_stub_probe_call_chain(stub_probe(@subject))
     end
 
     it "sets up the RR probe call chain" do
-      should_create_stub_probe_call_chain rr_stub_probe(@subject)
+      should create_stub_probe_call_chain(rr_stub_probe(@subject))
     end
 
-    def should_create_stub_probe_call_chain(creator)
-      class << @subject
-        def foobar(*args)
-          :original_value
-        end
-      end
+    it "#stub_probe creates a stub Scenario for method when passed a second argument" do
+      should create_scenario_with_method_name(stub_probe(@subject, :foobar))
+    end
+
+    it "#rr_stub_probe creates a stub Scenario for method when passed a second argument with rr_stub" do
+      should create_scenario_with_method_name(rr_stub_probe(@subject, :foobar))
+    end
+
+    it "raises error if passed a method name and a block" do
+      proc do
+        stub_probe(@object, :foobar) {}
+      end.should raise_error(ArgumentError, "Cannot pass in a method name and a block")
+    end
 
+    def create_scenario_with_method_name(scenario)
+      method_name = scenario.method_name
+      scenario.times_matcher.should == TimesCalledMatchers::AnyTimesMatcher.new
+      scenario.argument_expectation.class.should == RR::Expectations::AnyArgumentExpectation
+
+      @subject.foobar(:something).should == :original_value
+    end
+
+    def create_stub_probe_call_chain(creator)
       scenario = creator.foobar
       scenario.times_matcher.should == TimesCalledMatchers::AnyTimesMatcher.new
       scenario.argument_expectation.class.should == RR::Expectations::AnyArgumentExpectation
@@ -132,35 +232,76 @@ module Extensions
     
     before do
       @subject = Object.new
+      class << @subject
+        def foobar(*args)
+          :original_value
+        end
+      end
     end
 
     it "sets up the RR do_not_allow call chain" do
-      should_create_do_not_allow_call_chain do_not_allow(@subject)
+      should create_do_not_allow_call_chain(do_not_allow(@subject))
     end
 
     it "sets up the RR do_not_allow call chain with rr_do_not_allow" do
-      should_create_do_not_allow_call_chain rr_do_not_allow(@subject)
+      should create_do_not_allow_call_chain(rr_do_not_allow(@subject))
     end
 
     it "sets up the RR do_not_allow call chain" do
-      should_create_do_not_allow_call_chain dont_allow(@subject)
+      should create_do_not_allow_call_chain(dont_allow(@subject))
     end
 
     it "sets up the RR do_not_allow call chain with rr_do_not_allow" do
-      should_create_do_not_allow_call_chain rr_dont_allow(@subject)
+      should create_do_not_allow_call_chain(rr_dont_allow(@subject))
     end
 
-    def should_create_do_not_allow_call_chain(creator)
-      class << @subject
-        def foobar(*args)
-          :original_value
-        end
-      end
+    it "#do_not_allow creates a mock Scenario for method when passed a second argument" do
+      should create_scenario_with_method_name(do_not_allow(@subject, :foobar))
+    end
+
+    it "#rr_do_not_allow creates a mock Scenario for method when passed a second argument with rr_mock" do
+      should create_scenario_with_method_name(rr_do_not_allow(@subject, :foobar))
+    end
+
+    it "#dont_allow creates a mock Scenario for method when passed a second argument" do
+      should create_scenario_with_method_name(dont_allow(@subject, :foobar))
+    end
+
+    it "#rr_dont_allow creates a mock Scenario for method when passed a second argument with rr_mock" do
+      should create_scenario_with_method_name(rr_dont_allow(@subject, :foobar))
+    end
+
+    it "raises error if passed a method name and a block" do
+      proc do
+        do_not_allow(@object, :foobar) {}
+      end.should raise_error(ArgumentError, "Cannot pass in a method name and a block")
+    end
 
+    def create_scenario_with_method_name(scenario)
+      method_name = scenario.method_name
+      scenario.with(1, 2)
+      scenario.times_matcher.should == TimesCalledMatchers::IntegerMatcher.new(0)
+      scenario.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
+      scenario.argument_expectation.expected_arguments.should == [1, 2]
+
+      proc do
+        @subject.__send__(method_name, 1, 2)
+      end.should raise_error(Errors::TimesCalledError)
+      reset
+      nil
+    end
+
+    def create_do_not_allow_call_chain(creator)
       scenario = creator.foobar(1, 2)
       scenario.times_matcher.should == TimesCalledMatchers::IntegerMatcher.new(0)
       scenario.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
       scenario.argument_expectation.expected_arguments.should == [1, 2]
+
+      proc do
+        @subject.foobar(1, 2)
+      end.should raise_error(Errors::TimesCalledError)
+      reset
+      nil
     end
   end
 end

data/examples/rr/space/space_create_example.rb

@@ -1,7 +1,7 @@
 require "examples/example_helper"
 
 module RR
-describe Space, "#create_mock_creator" do
+describe Space, "#mock_creator" do
   it_should_behave_like "RR::Space"
 
   before do
@@ -10,14 +10,26 @@ describe Space, "#create_mock_creator" do
   end
 
   it "creates a MockCreator" do
-    creator = @space.create_mock_creator(@object)
+    creator = @space.mock_creator(@object)
     creator.foobar(1) {:baz}
     @object.foobar(1).should == :baz
     proc {@object.foobar(1)}.should raise_error(Errors::TimesCalledError)
   end
 
+  it "creates a mock Scenario for method when passed a second argument" do
+    creator = @space.mock_creator(@object, :foobar).with(1) {:baz}
+    @object.foobar(1).should == :baz
+    proc {@object.foobar(1)}.should raise_error(Errors::TimesCalledError)
+  end
+
+  it "raises error if passed a method name and a block" do
+    proc do
+      @space.mock_creator(@object, :foobar) {}
+    end.should raise_error(ArgumentError, "Cannot pass in a method name and a block")
+  end
+
   it "uses block definition when passed a block" do
-    creator = @space.create_mock_creator(@object) do |c|
+    creator = @space.mock_creator(@object) do |c|
       c.foobar(1) {:baz}
     end
     @object.foobar(1).should == :baz
@@ -25,7 +37,7 @@ describe Space, "#create_mock_creator" do
   end
 end
 
-describe Space, "#create_stub_creator" do
+describe Space, "#stub_creator" do
   it_should_behave_like "RR::Space"
 
   before do
@@ -35,14 +47,26 @@ describe Space, "#create_stub_creator" do
   end
 
   it "creates a StubCreator" do
-    creator = @space.create_stub_creator(@object)
+    creator = @space.stub_creator(@object)
     creator.foobar {:baz}
     @object.foobar.should == :baz
     @object.foobar.should == :baz
   end
 
+  it "creates a stub Scenario for method when passed a second argument" do
+    creator = @space.stub_creator(@object, :foobar).with(1) {:baz}
+    @object.foobar(1).should == :baz
+    @object.foobar(1).should == :baz
+  end
+
+  it "raises error if passed a method name and a block" do
+    proc do
+      @space.stub_creator(@object, :foobar) {}
+    end.should raise_error(ArgumentError, "Cannot pass in a method name and a block")
+  end
+
   it "uses block definition when passed a block" do
-    creator = @space.create_stub_creator(@object) do |c|
+    creator = @space.stub_creator(@object) do |c|
       c.foobar(1) {:return_value}
       c.foobar.with_any_args {:default}
       c.baz(1) {:baz_value}
@@ -53,7 +77,7 @@ describe Space, "#create_stub_creator" do
   end
 end
 
-describe Space, "#create_mock_probe_creator" do
+describe Space, "#mock_probe_creator" do
   it_should_behave_like "RR::Space"
 
   before do
@@ -66,14 +90,26 @@ describe Space, "#create_mock_probe_creator" do
   end
 
   it "creates a MockProbeCreator" do
-    creator = @space.create_mock_probe_creator(@object)
+    creator = @space.mock_probe_creator(@object)
     creator.foobar(1)
     @object.foobar(1).should == :original_foobar
     proc {@object.foobar(1)}.should raise_error(Errors::TimesCalledError)
   end
 
+  it "creates a mock probe Scenario for method when passed a second argument" do
+    creator = @space.mock_probe_creator(@object, :foobar).with(1)
+    @object.foobar(1).should == :original_foobar
+    proc {@object.foobar(1)}.should raise_error(Errors::TimesCalledError)
+  end
+
+  it "raises error if passed a method name and a block" do
+    proc do
+      @space.mock_probe_creator(@object, :foobar) {}
+    end.should raise_error(ArgumentError, "Cannot pass in a method name and a block")
+  end
+
   it "uses block definition when passed a block" do
-    creator = @space.create_mock_probe_creator(@object) do |c|
+    creator = @space.mock_probe_creator(@object) do |c|
       c.foobar(1)
     end
     @object.foobar(1).should == :original_foobar
@@ -81,7 +117,7 @@ describe Space, "#create_mock_probe_creator" do
   end
 end
 
-describe Space, "#create_stub_probe_creator" do
+describe Space, "#stub_probe_creator" do
   it_should_behave_like "RR::Space"
 
   before do
@@ -94,14 +130,26 @@ describe Space, "#create_stub_probe_creator" do
   end
 
   it "creates a StubProbeCreator" do
-    creator = @space.create_stub_probe_creator(@object)
+    creator = @space.stub_probe_creator(@object)
     creator.foobar
     @object.foobar(1).should == :original_foobar
     @object.foobar(1).should == :original_foobar
   end
 
+  it "creates a stub probe Scenario for method when passed a second argument" do
+    creator = @space.stub_probe_creator(@object, :foobar)
+    @object.foobar(1).should == :original_foobar
+    @object.foobar(1).should == :original_foobar
+  end
+
+  it "raises error if passed a method name and a block" do
+    proc do
+      @space.stub_probe_creator(@object, :foobar) {}
+    end.should raise_error(ArgumentError, "Cannot pass in a method name and a block")
+  end
+
   it "uses block definition when passed a block" do
-    creator = @space.create_stub_probe_creator(@object) do |c|
+    creator = @space.stub_probe_creator(@object) do |c|
       c.foobar(1)
     end
     @object.foobar(1).should == :original_foobar
@@ -109,7 +157,7 @@ describe Space, "#create_stub_probe_creator" do
   end
 end
 
-describe Space, "#create_do_not_allow_creator" do
+describe Space, "#do_not_allow_creator" do
   it_should_behave_like "RR::Space"
 
   before do
@@ -118,13 +166,24 @@ describe Space, "#create_do_not_allow_creator" do
   end
 
   it "creates a MockCreator" do
-    creator = @space.create_do_not_allow_creator(@object)
+    creator = @space.do_not_allow_creator(@object)
     creator.foobar(1)
     proc {@object.foobar(1)}.should raise_error(Errors::TimesCalledError)
   end
 
+  it "creates a do not allow Scenario for method when passed a second argument" do
+    creator = @space.do_not_allow_creator(@object, :foobar).with(1)
+    proc {@object.foobar(1)}.should raise_error(Errors::TimesCalledError)
+  end
+
+  it "raises error if passed a method name and a block" do
+    proc do
+      @space.do_not_allow_creator(@object, :foobar) {}
+    end.should raise_error(ArgumentError, "Cannot pass in a method name and a block")
+  end
+
   it "uses block definition when passed a block" do
-    creator = @space.create_do_not_allow_creator(@object) do |c|
+    creator = @space.do_not_allow_creator(@object) do |c|
       c.foobar(1)
     end
     proc {@object.foobar(1)}.should raise_error(Errors::TimesCalledError)

data/lib/rr/creator.rb

@@ -1,7 +1,7 @@
 module RR
   # RR::Creator is the superclass for all creators.
   class Creator
-    def initialize(space, subject)
+    def initialize(space, subject, &block)
       @space = space
       @subject = subject
       class << self

data/lib/rr/extensions/instance_methods.rb

@@ -12,26 +12,77 @@ module Extensions
       RR::Space.instance.reset
     end
 
-    # Sets up a MockCreator that generates a Double Scenario that
-    # acts like a mock.
-    #   mock(object).method_name(arg1, arg2) {return_value}
-    def mock(subject, &definition)
-      RR::Space.instance.create_mock_creator(subject, &definition)
+    # When passed the object, this method returns a MockCreator
+    # that generates a Double Scenario that acts like a mock.
+    #   mock(object).method_name_1 {return_value_1}
+    #   mock(object).method_name_2(arg1, arg2) {return_value_2}
+    #
+    # When passed the object and the method_name, this method returns
+    # a mock Scenario with the method already set.
+    #
+    # mock also takes a block for definitions.
+    #   mock(object) do
+    #     method_name_1 {return_value_1}
+    #     method_name_2(arg_1, arg_2) {return_value_2}
+    #   end
+    def mock(object, method_name=nil, &definition)
+      RR::Space.instance.mock_creator(object, method_name, &definition)
     end
 
-    # Sets up a StubCreator that generates a Double Scenario that
-    # acts like a stub.
-    #   stub(object).method_name {return_value}
-    def stub(subject, &definition)
-      RR::Space.instance.create_stub_creator(subject, &definition)
+    # When passed the object, this method returns a StubCreator
+    # that generates a Double Scenario that acts like a stub.
+    #   stub(object).method_name_1 {return_value_1}
+    #   stub(object).method_name_2(arg_1, arg_2) {return_value_2}
+    #
+    # When passed the object and the method_name, this method returns
+    # a stub Scenario with the method already set.
+    #
+    # stub also takes a block for definitions.
+    #   stub(object) do
+    #     method_name_1 {return_value_1}
+    #     method_name_2(arg_1, arg_2) {return_value_2}
+    #   end
+    def stub(object, method_name=nil, &definition)
+      RR::Space.instance.stub_creator(object, method_name, &definition)
     end
 
-    # Sets up a MockProbeCreator that generates a Double Scenario that
-    # acts like mock verifications while calling the actual method.
+    # When passed the object, this method returns a MockProbeCreator
+    # that generates a Double Scenario that acts like a mock probe.
     #
     #   mock_probe(controller.template).render(:partial => "my/socks")
     #
-    # Passing a block allows you to intercept the return value.
+    #   mock_probe(controller.template).render(:partial => "my/socks") do |html|
+    #     html.should include("My socks are wet")
+    #     html
+    #   end
+    #
+    #   mock_probe(controller.template).render(:partial => "my/socks") do |html|
+    #     html.should include("My socks are wet")
+    #     "My new return value"
+    #   end
+    #
+    # mock_probe also takes a block for definitions.
+    #   mock_probe(object) do
+    #     render(:partial => "my/socks")
+    #
+    #     render(:partial => "my/socks") do |html|
+    #       html.should include("My socks are wet")
+    #       html
+    #     end
+    #
+    #     render(:partial => "my/socks") do |html|
+    #       html.should include("My socks are wet")
+    #       html
+    #     end
+    #
+    #     render(:partial => "my/socks") do |html|
+    #       html.should include("My socks are wet")
+    #       "My new return value"
+    #     end
+    #   end
+    #
+    # Passing a block to the Scenario (after the method name and arguments)
+    # allows you to intercept the return value.
     # The return value can be modified, validated, and/or overridden by
     # passing in a block. The return value of the block will replace
     # the actual return value.
@@ -40,26 +91,55 @@ module Extensions
     #     html.should include("My socks are wet")
     #     "My new return value"
     #   end
-    def mock_probe(subject, &definition)
-      RR::Space.instance.create_mock_probe_creator(subject, &definition)
+    def mock_probe(object, method_name=nil, &definition)
+      RR::Space.instance.mock_probe_creator(object, method_name, &definition)
     end
 
-    # Sets up a StubProbeCreator that generates a Double Scenario that
-    # acts like mock verifications while calling the actual method.
+    # When passed the object, this method returns a StubProbeCreator
+    # that generates a Double Scenario that acts like a stub probe.
     #
-    #   mock_probe(User).new {|user| my_user}
+    #   stub_probe(User).new {|user| user}
+    #
+    #   stub_probe(User).new do |user|
+    #     mock(user).valid? {false}
+    #     user
+    #   end
+    #
+    #   stub_probe(User).new do |user|
+    #     mock_probe(user).friends {|friends| friends[0..3]}
+    #     user
+    #   end
     #
     # Passing a block allows you to intercept the return value.
     # The return value can be modified, validated, and/or overridden by
     # passing in a block. The return value of the block will replace
     # the actual return value.
     #
-    #   mock_probe(controller.template).render(:partial => "my/socks") do |html|
+    #   mock_probe(User) do
+    #     new {|user| user}
+    #
+    #     new do |user|
+    #       mock(user).valid? {false}
+    #     end
+    #
+    #     new do |user|
+    #       mock_probe(user).friends {|friends| friends[0..3]}
+    #       user
+    #     end
+    #   end
+    #
+    # Passing a block to the Scenario (after the method name and arguments)
+    # allows you to intercept the return value.
+    # The return value can be modified, validated, and/or overridden by
+    # passing in a block. The return value of the block will replace
+    # the actual return value.
+    #
+    #   stub_probe(controller.template).render(:partial => "my/socks") do |html|
     #     html.should include("My socks are wet")
     #     "My new return value"
     #   end
-    def stub_probe(subject, &definition)
-      RR::Space.instance.create_stub_probe_creator(subject, &definition)
+    def stub_probe(object, method_name=nil, &definition)
+      RR::Space.instance.stub_probe_creator(object, method_name, &definition)
     end
 
     # Same as mock_probe
@@ -68,8 +148,8 @@ module Extensions
     # Sets up a DoNotAllowCreator that generates a Double Scenario that
     # expects never to be called.
     #   do_not_allow(object).method_name
-    def do_not_allow(subject, &definition)
-      RR::Space.instance.create_do_not_allow_creator(subject, &definition)
+    def do_not_allow(subject, method_name=nil, &definition)
+      RR::Space.instance.do_not_allow_creator(subject, method_name, &definition)
     end
     alias_method :dont_allow, :do_not_allow
 

data/lib/rr/space.rb

@@ -26,28 +26,28 @@ module RR
     end
 
     # Creates a MockCreator.
-    def create_mock_creator(subject, &definition)
-      MockCreator.new(self, subject, &definition)
+    def mock_creator(subject, method_name=nil, &definition)
+      setup_creator MockCreator, subject, method_name, definition
     end
 
     # Creates a StubCreator.
-    def create_stub_creator(subject, &definition)
-      StubCreator.new(self, subject, &definition)
+    def stub_creator(subject, method_name=nil, &definition)
+      setup_creator StubCreator, subject, method_name, definition
     end
 
     # Creates a MockProbeCreator.
-    def create_mock_probe_creator(subject, &definition)
-      MockProbeCreator.new(self, subject, &definition)
+    def mock_probe_creator(subject, method_name=nil, &definition)
+      setup_creator MockProbeCreator, subject, method_name, definition
     end
 
     # Creates a StubProbeCreator.
-    def create_stub_probe_creator(subject, &definition)
-      StubProbeCreator.new(self, subject, &definition)
+    def stub_probe_creator(subject, method_name=nil, &definition)
+      setup_creator StubProbeCreator, subject, method_name, definition
     end
 
     # Creates a DoNotAllowCreator.
-    def create_do_not_allow_creator(subject, &definition)
-      DoNotAllowCreator.new(self, subject, &definition)
+    def do_not_allow_creator(subject, method_name=nil, &definition)
+      setup_creator DoNotAllowCreator, subject, method_name, definition
     end
 
     # Creates and registers a Scenario to be verified.
@@ -124,6 +124,15 @@ module RR
     end
 
     protected
+    def setup_creator(klass, subject, method_name, definition)
+      if method_name && definition
+        raise ArgumentError, "Cannot pass in a method name and a block"
+      end
+      creator = klass.new(self, subject, &definition)
+      return creator unless method_name
+      creator.__send__(method_name)
+    end
+    
     # Removes the ordered Scenarios from the list
     def reset_ordered_scenarios
       @ordered_scenarios.clear

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.3
 specification_version: 1
 name: rr
 version: !ruby/object:Gem::Version 
-  version: 0.2.4
-date: 2007-07-19 00:00:00 -07:00
+  version: 0.2.5
+date: 2007-07-21 00:00:00 -07:00
 summary: RR (Double Ruby) is a double framework that features a rich selection of double techniques and a terse syntax. http://xunitpatterns.com/Test%20Double.html
 require_paths: 
 - lib