rr 0.2.5 → 0.3.0

data/examples/rr/space/space_example.rb

@@ -17,12 +17,12 @@ describe Space, " class" do
   it "proxies to a singleton instance of Space" do
     create_double_args = nil
     (class << @space; self; end).class_eval do
-      define_method :create_double do |*args|
+      define_method :double do |*args|
         create_double_args = args
       end
     end
 
-    Space.create_double(:foo, :bar)
+    Space.double(:foo, :bar)
     create_double_args.should == [:foo, :bar]
   end
 end

data/examples/rr/space/space_register_example.rb

@@ -10,7 +10,7 @@ describe Space, "#register_ordered_scenario" do
     Space.instance = @space
     @object = Object.new
     @method_name = :foobar
-    @double = @space.create_double(@object, @method_name)
+    @double = @space.double(@object, @method_name)
   end
 
   after(:each) do
@@ -18,13 +18,13 @@ describe Space, "#register_ordered_scenario" do
   end
 
   it "adds the ordered scenario to the ordered_scenarios collection" do
-    scenario1 = @space.create_scenario(@double)
+    scenario1 = @space.scenario(@double)
 
     @space.ordered_scenarios.should == []
     @space.register_ordered_scenario scenario1
     @space.ordered_scenarios.should == [scenario1]
 
-    scenario2 = @space.create_scenario(@double)
+    scenario2 = @space.scenario(@double)
     @space.register_ordered_scenario scenario2
     @space.ordered_scenarios.should == [scenario1, scenario2]
   end

data/examples/rr/space/space_reset_example.rb

@@ -12,11 +12,11 @@ describe Space, "#reset" do
   end
 
   it "removes the ordered scenarios" do
-    double1 = @space.create_double(@object1, :foobar1)
-    double2 = @space.create_double(@object1, :foobar2)
+    double1 = @space.double(@object1, :foobar1)
+    double2 = @space.double(@object1, :foobar2)
 
-    scenario1 = @space.create_scenario(double1)
-    scenario2 = @space.create_scenario(double2)
+    scenario1 = @space.scenario(double1)
+    scenario2 = @space.scenario(double2)
 
     scenario1.ordered
     scenario2.ordered
@@ -28,14 +28,14 @@ describe Space, "#reset" do
   end
 
   it "resets all doubles" do
-    double1 = @space.create_double(@object1, @method_name)
+    double1 = @space.double(@object1, @method_name)
     double1_reset_calls = 0
     (class << double1; self; end).class_eval do
       define_method(:reset) do ||
         double1_reset_calls += 1
       end
     end
-    double2 = @space.create_double(@object2, @method_name)
+    double2 = @space.double(@object2, @method_name)
     double2_reset_calls = 0
     (class << double2; self; end).class_eval do
       define_method(:reset) do ||
@@ -59,7 +59,7 @@ describe Space, "#reset_double" do
   end
 
   it "resets the doubles" do
-    double = @space.create_double(@object, @method_name)
+    double = @space.double(@object, @method_name)
     @space.doubles[@object][@method_name].should === double
     @object.methods.should include("__rr__#{@method_name}")
 
@@ -69,8 +69,8 @@ describe Space, "#reset_double" do
   end
 
   it "removes the object from the doubles map when it has no doubles" do
-    double1 = @space.create_double(@object, :foobar1)
-    double2 = @space.create_double(@object, :foobar2)
+    double1 = @space.double(@object, :foobar1)
+    double2 = @space.double(@object, :foobar2)
 
     @space.doubles.include?(@object).should == true
     @space.doubles[@object][:foobar1].should_not be_nil
@@ -97,14 +97,14 @@ describe Space, "#reset_doubles" do
   end
 
   it "resets the double and removes it from the doubles list" do
-    double1 = @space.create_double(@object1, @method_name)
+    double1 = @space.double(@object1, @method_name)
     double1_reset_calls = 0
     (class << double1; self; end).class_eval do
       define_method(:reset) do ||
         double1_reset_calls += 1
       end
     end
-    double2 = @space.create_double(@object2, @method_name)
+    double2 = @space.double(@object2, @method_name)
     double2_reset_calls = 0
     (class << double2; self; end).class_eval do
       define_method(:reset) do ||

data/examples/rr/space/space_verify_example.rb

@@ -12,7 +12,7 @@ describe Space, "#verify_doubles" do
   end
 
   it "verifies and deletes the doubles" do
-    double1 = @space.create_double(@object1, @method_name)
+    double1 = @space.double(@object1, @method_name)
     double1_verify_calls = 0
     double1_reset_calls = 0
     (class << double1; self; end).class_eval do
@@ -23,7 +23,7 @@ describe Space, "#verify_doubles" do
         double1_reset_calls += 1
       end
     end
-    double2 = @space.create_double(@object2, @method_name)
+    double2 = @space.double(@object2, @method_name)
     double2_verify_calls = 0
     double2_reset_calls = 0
     (class << double2; self; end).class_eval do
@@ -53,7 +53,7 @@ describe Space, "#verify_double" do
   end
 
   it "verifies and deletes the double" do
-    double = @space.create_double(@object, @method_name)
+    double = @space.double(@object, @method_name)
     @space.doubles[@object][@method_name].should === double
     @object.methods.should include("__rr__#{@method_name}")
 
@@ -71,7 +71,7 @@ describe Space, "#verify_double" do
   end
 
   it "deletes the double when verifying the double raises an error" do
-    double = @space.create_double(@object, @method_name)
+    double = @space.double(@object, @method_name)
     @space.doubles[@object][@method_name].should === double
     @object.methods.should include("__rr__#{@method_name}")
 
@@ -97,11 +97,11 @@ describe Space, "#verify_ordered_scenario", :shared => true do
     @space = Space.new
     @object = Object.new
     @method_name = :foobar
-    @double = @space.create_double(@object, @method_name)
+    @double = @space.double(@object, @method_name)
   end
 
   it "raises an error when Scenario is NonTerminal" do
-    scenario = @space.create_scenario(@double)
+    scenario = @space.scenario(@double)
     @space.register_ordered_scenario(scenario)
 
     scenario.any_number_of_times
@@ -120,7 +120,7 @@ describe Space, "#verify_ordered_scenario where the passed in scenario is at the
   it_should_behave_like "RR::Space#verify_ordered_scenario"
 
   it "keeps the scenario when times called is not verified" do
-    scenario = @space.create_scenario(@double)
+    scenario = @space.scenario(@double)
     @space.register_ordered_scenario(scenario)
 
     scenario.twice
@@ -131,7 +131,7 @@ describe Space, "#verify_ordered_scenario where the passed in scenario is at the
   end
   
   it "removes the scenario when times called expectation should no longer be attempted" do
-    scenario = @space.create_scenario(@double)
+    scenario = @space.scenario(@double)
     @space.register_ordered_scenario(scenario)
 
     scenario.with(1).once
@@ -147,8 +147,8 @@ describe Space, "#verify_ordered_scenario where the passed in scenario is not at
   it_should_behave_like "RR::Space#verify_ordered_scenario"
   
   it "raises error" do
-    first_scenario = create_scenario
-    second_scenario = create_scenario
+    first_scenario = scenario
+    second_scenario = scenario
 
     proc do
       @space.verify_ordered_scenario(second_scenario)
@@ -160,8 +160,8 @@ describe Space, "#verify_ordered_scenario where the passed in scenario is not at
     )
   end
 
-  def create_scenario
-    scenario = @space.create_scenario(@double).once
+  def scenario
+    scenario = @space.scenario(@double).once
     @space.register_ordered_scenario(scenario)
     scenario
   end

data/examples/rr/test_unit/test_unit_integration_test.rb

@@ -21,12 +21,21 @@ class TestUnitIntegrationTest < Test::Unit::TestCase
     assert_equal :baz, @subject.foobar("any", "thing")
   end
 
-  def test_using_a_probe
+  def test_using_a_mock_probe
     def @subject.foobar
       :baz
     end
 
-    probe(@subject).foobar
+    mock.probe(@subject).foobar
+    assert_equal :baz, @subject.foobar
+  end
+
+  def test_using_a_stub_probe
+    def @subject.foobar
+      :baz
+    end
+
+    stub.probe(@subject).foobar
     assert_equal :baz, @subject.foobar
   end
 

data/lib/rr.rb

@@ -1,23 +1,21 @@
+require "rr/errors/rr_error"
+require "rr/errors/scenario_definition_error"
+require "rr/errors/scenario_not_found_error"
+require "rr/errors/scenario_order_error"
+require "rr/errors/argument_equality_error"
+require "rr/errors/times_called_error"
+
 require "rr/space"
 require "rr/double"
 require "rr/hash_with_object_id_key"
 
-require "rr/creator"
-require "rr/mock_creator"
-require "rr/stub_creator"
-require "rr/mock_probe_creator"
-require "rr/stub_probe_creator"
-require "rr/do_not_allow_creator"
+require "rr/scenario_method_proxy"
+
+require "rr/scenario_creator"
 
 require "rr/scenario"
 require "rr/scenario_matches"
 
-require "rr/errors/rr_error"
-require "rr/errors/scenario_not_found_error"
-require "rr/errors/scenario_order_error"
-require "rr/errors/argument_equality_error"
-require "rr/errors/times_called_error"
-
 require "rr/expectations/argument_equality_expectation"
 require "rr/expectations/any_argument_expectation"
 require "rr/expectations/times_called_expectation"

data/lib/rr/errors/scenario_definition_error.rb

@@ -0,0 +1,6 @@
+module RR
+module Errors
+  class ScenarioDefinitionError < RRError
+  end
+end
+end

data/lib/rr/extensions/instance_methods.rb

@@ -12,57 +12,90 @@ module Extensions
       RR::Space.instance.reset
     end
 
-    # 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
+    # This method sets the Scenario to have a mock strategy. A mock strategy
+    # sets the default state of the Scenario to expect the method call
+    # with arguments exactly one time. The Scenario's expectations can be
+    # changed.
+    #
+    # This method can be chained with probe.
+    #   mock.probe(subject).method_name_1
+    #   or
+    #   probe.mock(subject).method_name_1
+    #
+    # When passed the subject, a ScenarioMethodProxy is returned. Passing
+    # a method with arguments to the proxy will set up expectations that
+    # the a call to the subject's method with the arguments will happen,
+    # and return the prescribed value.
+    #   mock(subject).method_name_1 {return_value_1}
+    #   mock(subject).method_name_2(arg1, arg2) {return_value_2}
+    #
+    # When passed the subject and the method_name, this method returns
     # a mock Scenario with the method already set.
     #
+    #   mock(subject, :method_name_1) {return_value_1}
+    #   mock(subject, :method_name_2).with(arg1, arg2) {return_value_2}
+    #
     # mock also takes a block for definitions.
-    #   mock(object) do
+    #   mock(subject) 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)
+    def mock(subject=ScenarioCreator::NO_SUBJECT_ARG, method_name=nil, &definition)
+      creator = RR::Space.scenario_creator
+      creator.mock(subject, method_name, &definition)
     end
 
-    # 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
+
+    # This method sets the Scenario to have a stub strategy. A stub strategy
+    # sets the default state of the Scenario to expect the method call
+    # with any arguments any number of times. The Scenario's
+    # expectations can be changed.
+    #
+    # This method can be chained with probe.
+    #   stub.probe(subject).method_name_1
+    #   or
+    #   probe.stub(subject).method_name_1
+    #
+    # When passed the subject, a ScenarioMethodProxy is returned. Passing
+    # a method with arguments to the proxy will set up expectations that
+    # the a call to the subject's method with the arguments will happen,
+    # and return the prescribed value.
+    #   stub(subject).method_name_1 {return_value_1}
+    #   stub(subject).method_name_2(arg_1, arg_2) {return_value_2}
+    #
+    # When passed the subject and the method_name, this method returns
     # a stub Scenario with the method already set.
     #
+    #   mock(subject, :method_name_1) {return_value_1}
+    #   mock(subject, :method_name_2).with(arg1, arg2) {return_value_2}
+    #
     # stub also takes a block for definitions.
-    #   stub(object) do
+    #   stub(subject) 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)
+    def stub(subject=ScenarioCreator::NO_SUBJECT_ARG, method_name=nil, &definition)
+      creator = RR::Space.scenario_creator
+      creator.stub(subject, method_name, &definition)
     end
 
-    # When passed the object, this method returns a MockProbeCreator
-    # that generates a Double Scenario that acts like a mock probe.
+    # This method add probe capabilities to the Scenario. probe can be called
+    # with mock or stub.
     #
-    #   mock_probe(controller.template).render(:partial => "my/socks")
+    #   mock.probe(controller.template).render(:partial => "my/socks")
     #
-    #   mock_probe(controller.template).render(:partial => "my/socks") do |html|
+    #   stub.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|
+    #   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
+    # mock.probe also takes a block for definitions.
+    #   mock.probe(subject) do
     #     render(:partial => "my/socks")
     #
     #     render(:partial => "my/socks") do |html|
@@ -87,71 +120,38 @@ module Extensions
     # 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(controller.template).render(:partial => "my/socks") do |html|
     #     html.should include("My socks are wet")
     #     "My new return value"
     #   end
-    def mock_probe(object, method_name=nil, &definition)
-      RR::Space.instance.mock_probe_creator(object, method_name, &definition)
+    def probe(subject=ScenarioCreator::NO_SUBJECT_ARG, method_name=nil, &definition)
+      creator = RR::Space.scenario_creator
+      creator.probe(subject, method_name, &definition)
     end
 
-    # When passed the object, this method returns a StubProbeCreator
-    # that generates a Double Scenario that acts like a stub probe.
-    #
-    #   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(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(object, method_name=nil, &definition)
-      RR::Space.instance.stub_probe_creator(object, method_name, &definition)
-    end
-
-    # Same as mock_probe
-    alias_method :probe, :mock_probe
-
-    # 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, method_name=nil, &definition)
-      RR::Space.instance.do_not_allow_creator(subject, method_name, &definition)
+    # This method sets the Scenario to have a do_not_call strategy.
+    # A do_not_call strategy sets the default state of the Scenario
+    # to expect never to be called. The Scenario's expectations can be
+    # changed.
+    #
+    # The following example sets the expectation that subject.method_name
+    # will never be called with arg1 and arg2.
+    #
+    #   do_not_allow(subject).method_name(arg1, arg2)
+    #
+    # do_not_call also supports a block sytnax.
+    #    do_not_call(subject) do |m|
+    #      m.method1 # Do not allow method1 with any arguments
+    #      m.method2(arg1, arg2) # Do not allow method2 with arguments arg1 and arg2
+    #      m.method3.with_no_args # Do not allow method3 with no arguments
+    #    end
+    def do_not_call(subject=ScenarioCreator::NO_SUBJECT_ARG, method_name=nil, &definition)
+      creator = RR::Space.scenario_creator
+      creator.do_not_call(subject, method_name, &definition)
     end
-    alias_method :dont_allow, :do_not_allow
+    alias_method :dont_call, :do_not_call
+    alias_method :do_not_allow, :do_not_call
+    alias_method :dont_allow, :do_not_call
 
     # Returns a AnyTimesMatcher. This is meant to be passed in as an argument
     # to Scenario#times.