rr 0.2.5 → 0.3.0

data/CHANGES

@@ -1,3 +1,8 @@
+* 0.3.0
+- ScenarioCreator strategy method chaining
+- Removed mock_probe
+- Removed stub_probe
+
 * 0.2.5
 - mock takes method_name argument
 - stub takes method_name argument

data/README

@@ -7,44 +7,54 @@ http://xunitpatterns.com/Test%20Double.html
 Currently RR implements mocks, stubs, and probes. It is a goal of
 RR to support a wide range of double techniques and patterns.
 
-== Mocking
+== Mocks
 http://xunitpatterns.com/Mock%20Object.html
   view = controller.template
   mock(view).render(:partial => "user_info") {"Information"}
 
-== Stubbing
+  # or
+  mock(view) do
+    render(:partial => "user_info") {"Information"}
+  end
+
+== Stubs
 http://xunitpatterns.com/Test%20Stub.html
   jane = User.new
   stub(User).find('42') {jane}
-  mock(jane).valid? {true}
 
-== Mock Probing
+== Mock Probes
 Add verifications that a method was called while actually calling it.
 The following example verifies render partial will be called and
 renders the partial.
 
   view = controller.template
-  probe(view).render(:partial => "user_info")
-  # or mock_probe.render(:partial => "user_info")
+  mock.probe(view).render(:partial => "right_navigation")
+  mock.probe(view).render(:partial => "user_info") do |html|
+    html.should include("John Doe")
+    "Different html"
+  end
 
-Probes also support after_call callbacks. This is useful for Stubbing out
+Probes support after_call callbacks. This is useful for Stubbing out
 a class method and getting its return value. You can also change the return value.
 This technique is also useful for verifying that you are mocking exists and
 functions proberly, thereby testing you interface.
 For example, using ActiveRecord:
 
   probe(User).find('5') do |user|
+    mock.probe(user).projects do |projects|
+      projects[0..3]
+    end
     mock(user).valid? {false}
     user
   end
 
-== Mock Stubbing
+== Stub Probes
 Intercept the return value of a method call.
 The following example verifies render partial will be called and
 renders the partial.
 
   view = controller.template
-  stub_probe(view).render(:partial => "user_info") do |html|
+  stub.probe(view).render(:partial => "user_info") do |html|
     html.should include("Joe Smith")
     html
   end
@@ -65,6 +75,7 @@ Here is RR compared to other mock frameworks:
   flexmock(User).should_receive(:find).with('42').and_return(jane) # Flexmock
   User.should_receive(:find).with('42').and_return(jane) # Rspec
   User.expects(:find).with('42').returns {jane} # Mocha
+  User.should_receive(:find).with('42') {jane} # Rspec using return value blocks
   mock(User).find('42') {jane} # RR
 
 == Special Thanks To

data/Rakefile

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

data/examples/example_suite.rb

@@ -42,4 +42,4 @@ end
 
 if $0 == __FILE__
   ExampleSuite.new.run
-end
+end

data/examples/high_level_example.rb

@@ -67,7 +67,7 @@ describe "RR probe:" do
 
   it "probes via inline call" do
     expected_to_s_value = @obj.to_s
-    probe(@obj).to_s
+    mock.probe(@obj).to_s
     @obj.to_s.should == expected_to_s_value
     proc {@obj.to_s}.should raise_error
   end
@@ -76,8 +76,8 @@ describe "RR probe:" do
     def @obj.to_s(arg)
       "Original to_s with arg #{arg}"
     end
-    probe(@obj).to_s(:foo).ordered
-    probe(@obj).to_s(:bar).twice.ordered
+    mock.probe(@obj).to_s(:foo).ordered
+    mock.probe(@obj).to_s(:bar).twice.ordered
 
     @obj.to_s(:foo).should == "Original to_s with arg foo"
     @obj.to_s(:bar).should == "Original to_s with arg bar"
@@ -94,7 +94,7 @@ describe "RR probe:" do
       :original_value_2
     end
 
-    probe @obj do |c|
+    mock.probe @obj do |c|
       c.foobar_1(1)
       c.foobar_2
     end

data/examples/rr/double/double_dispatching_example.rb

@@ -7,7 +7,7 @@ describe Double, "method dispatching", :shared => true do
     @object = Object.new
     @method_name = :foobar
     @object.methods.should_not include(@method_name.to_s)
-    @double = @space.create_double(@object, @method_name)
+    @double = @space.double(@object, @method_name)
   end
 end
 
@@ -17,11 +17,11 @@ describe Double, " method dispatching where method name has a ! in it" do
     @object = Object.new
     @method_name = :foobar!
     @object.methods.should_not include(@method_name.to_s)
-    @double = @space.create_double(@object, @method_name)
+    @double = @space.double(@object, @method_name)
   end
 
   it "executes the block" do
-    scenario = @space.create_scenario(@double)
+    scenario = @space.scenario(@double)
     scenario.with(1, 2) {:return_value}
      @object.foobar!(1, 2).should == :return_value
   end
@@ -33,11 +33,11 @@ describe Double, " method dispatching where method name has a ? in it" do
     @object = Object.new
     @method_name = :foobar?
     @object.methods.should_not include(@method_name.to_s)
-    @double = @space.create_double(@object, @method_name)
+    @double = @space.double(@object, @method_name)
   end
 
   it "executes the block" do
-    scenario = @space.create_scenario(@double)
+    scenario = @space.scenario(@double)
     scenario.with(1, 2) {:return_value}
     @object.foobar?(1, 2).should == :return_value
   end
@@ -53,7 +53,7 @@ describe Double, " method dispatching where the scenario takes a block" do
         yield(a,b)
       end
     end
-    scenario = @space.create_scenario(@double)
+    scenario = @space.scenario(@double)
     scenario.with(1, 2).implemented_by(method_fixture.method(:method_with_block))
     @object.foobar(1, 2) {|a, b| [b, a]}.should == [2, 1]
   end
@@ -63,11 +63,11 @@ describe Double, " method dispatching where there are no scenarios with duplicat
   it_should_behave_like "RR::Double method dispatching"
 
   it "dispatches to Scenario that have an exact match" do
-    scenario1_with_exact_match = @space.create_scenario(@double)
+    scenario1_with_exact_match = @space.scenario(@double)
     scenario1_with_exact_match.with(:exact_match_1).returns {:return_1}
-    scenario_with_no_match = @space.create_scenario(@double)
+    scenario_with_no_match = @space.scenario(@double)
     scenario_with_no_match.with("nothing that matches").returns {:no_match}
-    scenario2_with_exact_match = @space.create_scenario(@double)
+    scenario2_with_exact_match = @space.scenario(@double)
     scenario2_with_exact_match.with(:exact_match_2).returns {:return_2}
 
     @object.foobar(:exact_match_1).should == :return_1
@@ -75,9 +75,9 @@ describe Double, " method dispatching where there are no scenarios with duplicat
   end
 
   it "dispatches to Scenario that have a wildcard match" do
-    scenario_with_wildcard_match = @space.create_scenario(@double)
+    scenario_with_wildcard_match = @space.scenario(@double)
     scenario_with_wildcard_match.with_any_args.returns {:wild_card_value}
-    scenario_with_no_match = @space.create_scenario(@double)
+    scenario_with_no_match = @space.scenario(@double)
     scenario_with_no_match.with("nothing that matches").returns {:no_match}
 
     @object.foobar(:wildcard_match_1).should == :wild_card_value
@@ -89,10 +89,10 @@ describe Double, " method dispatching where there are scenarios" do
   it_should_behave_like "RR::Double method dispatching"
 
   it "raises ScenarioNotFoundError error when arguments do not match a scenario" do
-    scenario_1 = @space.create_scenario(@double)
+    scenario_1 = @space.scenario(@double)
     scenario_1.with(1, 2)
 
-    scenario_2 = @space.create_scenario(@double)
+    scenario_2 = @space.scenario(@double)
     scenario_2.with(3)
 
     proc {@object.foobar(:arg1, :arg2)}.should raise_error(
@@ -108,38 +108,38 @@ describe Double, " method dispatching where there are Scenarios with NonTerminal
   it_should_behave_like "RR::Double method dispatching"
 
   it "dispatches to Scenario with exact match" do
-    scenario = create_scenario(1, 2) {:return_value}
+    scenario = scenario(1, 2) {:return_value}
     @object.foobar(1, 2).should == :return_value
   end
 
   it "matches to the last Scenario that was registered with an exact match" do
-    scenario_1 = create_scenario(1, 2) {:value_1}
-    scenario_2 = create_scenario(1, 2) {:value_2}
+    scenario_1 = scenario(1, 2) {:value_1}
+    scenario_2 = scenario(1, 2) {:value_2}
 
     @object.foobar(1, 2).should == :value_2
   end
 
   it "dispatches to Scenario with wildcard match" do
-    scenario = create_scenario(anything) {:return_value}
+    scenario = scenario(anything) {:return_value}
     @object.foobar(:dont_care).should == :return_value
   end
 
   it "matches to the last Scenario that was registered with a wildcard match" do
-    scenario_1 = create_scenario(anything) {:value_1}
-    scenario_2 = create_scenario(anything) {:value_2}
+    scenario_1 = scenario(anything) {:value_1}
+    scenario_2 = scenario(anything) {:value_2}
 
     @object.foobar(:dont_care).should == :value_2
   end
 
   it "matches to Scenario with exact match Scenario even when a Scenario with wildcard match was registered later" do
-    exact_scenario_registered_first = create_scenario(1, 2) {:exact_first}
-    wildcard_scenario_registered_last = create_scenario(anything, anything) {:wildcard_last}
+    exact_scenario_registered_first = scenario(1, 2) {:exact_first}
+    wildcard_scenario_registered_last = scenario(anything, anything) {:wildcard_last}
 
     @object.foobar(1, 2).should == :exact_first
   end
 
-  def create_scenario(*arguments, &return_value)
-    scenario = @space.create_scenario(@double)
+  def scenario(*arguments, &return_value)
+    scenario = @space.scenario(@double)
     scenario.with(*arguments).any_number_of_times.returns(&return_value)
     scenario.should_not be_terminal
     scenario
@@ -150,30 +150,30 @@ describe Double, " method dispatching where there are Terminal Scenarios with du
   it_should_behave_like "RR::Double method dispatching"
 
   it "dispatches to Scenario that have an exact match" do
-    scenario1_with_exact_match = create_scenario(:exact_match) {:return_1}
+    scenario1_with_exact_match = scenario(:exact_match) {:return_1}
 
     @object.foobar(:exact_match).should == :return_1
   end
 
   it "dispatches to the first Scenario that have an exact match" do
-    scenario1_with_exact_match = create_scenario(:exact_match) {:return_1}
-    scenario2_with_exact_match = create_scenario(:exact_match) {:return_2}
+    scenario1_with_exact_match = scenario(:exact_match) {:return_1}
+    scenario2_with_exact_match = scenario(:exact_match) {:return_2}
 
     @object.foobar(:exact_match).should == :return_1
   end
 
   it "dispatches the second Scenario with an exact match
       when the first scenario's Times Called expectation is satisfied" do
-    scenario1_with_exact_match = create_scenario(:exact_match) {:return_1}
-    scenario2_with_exact_match = create_scenario(:exact_match) {:return_2}
+    scenario1_with_exact_match = scenario(:exact_match) {:return_1}
+    scenario2_with_exact_match = scenario(:exact_match) {:return_2}
 
     @object.foobar(:exact_match)
     @object.foobar(:exact_match).should == :return_2
   end
 
   it "raises TimesCalledError when all of the scenarios Times Called expectation is satisfied" do
-    scenario1_with_exact_match = create_scenario(:exact_match) {:return_1}
-    scenario2_with_exact_match = create_scenario(:exact_match) {:return_2}
+    scenario1_with_exact_match = scenario(:exact_match) {:return_1}
+    scenario2_with_exact_match = scenario(:exact_match) {:return_2}
 
     @object.foobar(:exact_match)
     @object.foobar(:exact_match)
@@ -182,8 +182,8 @@ describe Double, " method dispatching where there are Terminal Scenarios with du
     end.should raise_error(Errors::TimesCalledError)
   end
 
-  def create_scenario(*arguments, &return_value)
-    scenario = @space.create_scenario(@double)
+  def scenario(*arguments, &return_value)
+    scenario = @space.scenario(@double)
     scenario.with(*arguments).once.returns(&return_value)
     scenario.should be_terminal
     scenario
@@ -194,30 +194,30 @@ describe Double, " method dispatching where there are scenarios with duplicate W
   it_should_behave_like "RR::Double method dispatching"
 
   it "dispatches to Scenario that have a wildcard match" do
-    scenario_1 = create_scenario {:return_1}
+    scenario_1 = scenario {:return_1}
 
     @object.foobar(:anything).should == :return_1
   end
 
   it "dispatches to the first Scenario that has a wildcard match" do
-    scenario_1 = create_scenario {:return_1}
-    scenario_2 = create_scenario {:return_2}
+    scenario_1 = scenario {:return_1}
+    scenario_2 = scenario {:return_2}
 
     @object.foobar(:anything).should == :return_1
   end
 
   it "dispatches the second Scenario with a wildcard match
       when the first scenario's Times Called expectation is satisfied" do
-    scenario_1 = create_scenario {:return_1}
-    scenario_2 = create_scenario {:return_2}
+    scenario_1 = scenario {:return_1}
+    scenario_2 = scenario {:return_2}
 
     @object.foobar(:anything)
     @object.foobar(:anything).should == :return_2
   end
 
   it "raises TimesCalledError when all of the scenarios Times Called expectation is satisfied" do
-    scenario_1 = create_scenario {:return_1}
-    scenario_2 = create_scenario {:return_2}
+    scenario_1 = scenario {:return_1}
+    scenario_2 = scenario {:return_2}
 
     @object.foobar(:anything)
     @object.foobar(:anything)
@@ -226,8 +226,8 @@ describe Double, " method dispatching where there are scenarios with duplicate W
     end.should raise_error(Errors::TimesCalledError)
   end
 
-  def create_scenario(&return_value)
-    scenario = @space.create_scenario(@double)
+  def scenario(&return_value)
+    scenario = @space.scenario(@double)
     scenario.with_any_args.once.returns(&return_value)
     scenario.should be_terminal
     scenario

data/examples/rr/double/double_verify_example.rb

@@ -7,7 +7,7 @@ describe Double, "#verify" do
     @object = Object.new
     @method_name = :foobar
     @object.methods.should_not include(@method_name.to_s)
-    @double = @space.create_double(@object, @method_name)
+    @double = @space.double(@object, @method_name)
   end
 
   it "verifies each scenario was met" do

data/examples/rr/expectations/times_called_expectation/times_called_expectation_helper.rb

@@ -5,8 +5,8 @@ module Expectations
       @space = Space.new
       @object = Object.new
       @method_name = :foobar
-      @double = @space.create_double(@object, @method_name)
-      @scenario = @space.create_scenario(@double)
+      @double = @space.double(@object, @method_name)
+      @scenario = @space.scenario(@double)
       @scenario.with_any_args
     end
 

data/examples/rr/extensions/instance_methods_creator_example.rb

@@ -14,6 +14,10 @@ module Extensions
       end
     end
 
+    it "returns a ScenarioCreator when passed no arguments" do
+      mock.should be_instance_of(ScenarioCreator)
+    end
+
     it "sets up the RR mock call chain" do
       should create_mock_call_chain(mock(@subject))
     end
@@ -68,6 +72,10 @@ module Extensions
       end
     end
 
+    it "returns a ScenarioCreator when passed no arguments" do
+      stub.should be_instance_of(ScenarioCreator)
+    end
+
     it "sets up the RR stub call chain" do
       should create_stub_call_chain(stub(@subject))
     end
@@ -106,7 +114,7 @@ module Extensions
     end
   end
 
-  describe InstanceMethods, "#probe and #mock_probe" do
+  describe InstanceMethods, "#probe and #mock" do
     it_should_behave_like "RR::Extensions::InstanceMethods"
 
     before do
@@ -118,41 +126,45 @@ module Extensions
       end      
     end
 
+    it "#probe returns a ScenarioCreator when passed no arguments" do
+      probe.should be_instance_of(ScenarioCreator)
+    end
+
     it "#probe sets up the RR probe call chain" do
-      should create_mock_probe_call_chain(probe(@subject))
+      should create_mock_probe_call_chain(mock.probe(@subject))
     end
 
     it "#rr_probe sets up the RR probe call chain" do
-      should create_mock_probe_call_chain(rr_probe(@subject))
+      should create_mock_probe_call_chain(rr_mock.probe(@subject))
     end
 
     it "#mock_probe sets up the RR probe call chain" do
-      should create_mock_probe_call_chain(mock_probe(@subject))
+      should create_mock_probe_call_chain(mock.probe(@subject))
     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))
+      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))
+      should create_scenario_with_method_name(mock.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))
+      should create_scenario_with_method_name(rr_probe.mock(@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))
+      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))
+      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) {}
+        mock.probe(@object, :foobar) {}
       end.should raise_error(ArgumentError, "Cannot pass in a method name and a block")
     end
 
@@ -176,7 +188,7 @@ module Extensions
     end
   end
 
-  describe InstanceMethods, "#stub_probe" do
+  describe InstanceMethods, "#stub and #probe" do
     it_should_behave_like "RR::Extensions::InstanceMethods"
 
     before do
@@ -188,25 +200,29 @@ module Extensions
       end
     end
 
+    it "returns a ScenarioCreator when passed no arguments" do
+      stub.probe.should be_instance_of(ScenarioCreator)
+    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
 
-    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))
+    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))
+    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) {}
+        stub.probe(@object, :foobar) {}
       end.should raise_error(ArgumentError, "Cannot pass in a method name and a block")
     end
 
@@ -223,7 +239,7 @@ module Extensions
       scenario.times_matcher.should == TimesCalledMatchers::AnyTimesMatcher.new
       scenario.argument_expectation.class.should == RR::Expectations::AnyArgumentExpectation
 
-      @subject.foobar(:something).should == :original_value
+      @subject.foobar(1, 2).should == :original_value
     end
   end
 
@@ -239,35 +255,29 @@ module Extensions
       end
     end
 
-    it "sets up the RR do_not_allow call chain" do
-      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))
+    it "returns a ScenarioCreator when passed no arguments" do
+      do_not_allow.should be_instance_of(ScenarioCreator)
     end
 
     it "sets up the RR do_not_allow call chain" do
+      should create_do_not_allow_call_chain(do_not_call(@subject))
+      should create_do_not_allow_call_chain(rr_do_not_call(@subject))
+      should create_do_not_allow_call_chain(dont_call(@subject))
+      should create_do_not_allow_call_chain(rr_dont_call(@subject))
+      should create_do_not_allow_call_chain(do_not_allow(@subject))
+      should create_do_not_allow_call_chain(rr_do_not_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))
     end
 
-    it "#do_not_allow creates a mock Scenario for method when passed a second argument" do
+    it "creates a mock Scenario for method when passed a second argument" do
+      should create_scenario_with_method_name(do_not_call(@subject, :foobar))
+      should create_scenario_with_method_name(rr_do_not_call(@subject, :foobar))
+      should create_scenario_with_method_name(dont_call(@subject, :foobar))
+      should create_scenario_with_method_name(rr_dont_call(@subject, :foobar))
       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