rr 0.1.5 → 0.1.6

data/CHANGES

@@ -1,3 +1,6 @@
+* 0.1.6
+- [#12120] probe allows a the return value to be intercepted
+
 * 0.1.5
 - TimesCalledExpectation says how many times were called and how many times called were expected on error
 

data/README

@@ -25,6 +25,13 @@ renders the partial.
 
   view = controller.template
   probe(view).render(:partial => "user_info")
+
+Probes also support after_call callbacks. This is useful for Stubbing out
+a class method and getting its return value. For example, using ActiveRecord:
+
+  probe(User).find('5') do |user|
+    mock(user).valid? {false}
+  end
   
 == Block Syntax
   script = MyScript.new

data/Rakefile

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

data/examples/rr/probe_creator_example.rb

@@ -78,6 +78,18 @@ describe ProbeCreator, "#method_missing" do
     @subject.foobar(1, 2).should == :baz
     proc {@subject.foobar(1, 2)}.should raise_error(Errors::TimesCalledError)
   end
+
+  it "sets after_call on the scenario when passed a block" do
+    real_value = Object.new
+    (class << @subject; self; end).class_eval do
+      define_method(:foobar) {real_value}
+    end
+    @creator.foobar(1, 2) {|value| mock(value).a_method {99}}
+
+    return_value = @subject.foobar(1, 2)
+    return_value.should === return_value
+    return_value.a_method.should == 99
+  end
 end
 
 end

data/examples/rr/scenario_example.rb

@@ -195,6 +195,40 @@ describe Scenario, "#yields" do
   end
 end
 
+describe Scenario, "#after_call" do
+  it_should_behave_like "RR::Scenario"
+
+  it "returns self" do
+    @scenario.after_call {}.should === @scenario
+  end
+
+  it "receives the return value in the block" do
+    return_value = {}
+    @scenario.returns(return_value).after_call do |value|
+      value[:foo] = :bar
+    end
+
+    actual_value = @scenario.call
+    actual_value.should === return_value
+    actual_value.should == {:foo => :bar}
+  end
+
+  it "allows after_call to mock the return value" do
+    return_value = Object.new
+    @scenario.with_any_args.returns(return_value).after_call do |value|
+      mock(value).inner_method(1) {:baz}
+    end
+
+    @object.foobar.inner_method(1).should == :baz
+  end
+
+  it "raises an error when not passed a block" do
+    proc do
+      @scenario.after_call
+    end.should raise_error(ArgumentError, "after_call expects a block")
+  end
+end
+
 describe Scenario, "#returns" do
   it_should_behave_like "RR::Scenario"
 

data/lib/rr/probe_creator.rb

@@ -3,15 +3,24 @@ module RR
   # a Scenario that acts like a probe.
   #
   # The following example probes method_name with arg1 and arg2
-  # returning return_value.
+  # returning the actual value of the method. The block is an after callback
+  # that intercepts the return value. Mocks or other modifications can
+  # be done to the return value.
   #
-  #   probe(subject).method_name(arg1, arg2) { return_value }
+  #   probe(subject).method_name(arg1, arg2) { |return_value| }
   #
-  # The ProbeCreator also supports a block sytnax.
+  # The ProbeCreator also supports a block sytnax. The block accepts
+  # a after_call callback, instead of a return value as with MockCreator
+  # and StubCreator.
   #
-  #    probe(subject) do |m|
-  #      m.method_name(arg1, arg2) { return_value }
+  #    probe(User) do |m|
+  #      m.find('4') do |user|
+  #        mock(user).valid? {false}
+  #      end
   #    end
+  #
+  #   user = User.find('4')
+  #   user.valid? # false
   class ProbeCreator
     instance_methods.each { |m| undef_method m unless m =~ /^__/ }
     
@@ -22,10 +31,12 @@ module RR
     end
 
     protected
-    def method_missing(method_name, *args, &returns)
+    def method_missing(method_name, *args, &after_call)
       double = @space.create_double(@subject, method_name)
       scenario = @space.create_scenario(double)
       scenario.with(*args).once.implemented_by(double.original_method)
+      scenario.after_call(&after_call) if after_call
+      scenario
     end
   end
 end

data/lib/rr/scenario.rb

@@ -11,6 +11,7 @@ module RR
       @argument_expectation = nil
       @times_called_expectation = nil
       @times_called = 0
+      @after_call = nil
       @yields = nil
     end
 
@@ -114,6 +115,37 @@ module RR
       @ordered
     end
 
+    # Scenario#yields sets the Scenario to invoke a passed in block when
+    # the Scenario is called.
+    # An Expection will be raised if no block is passed in when the
+    # Scenario is called.
+    #
+    # Passing in a block sets the return value.
+    #
+    #   mock(subject).method_name.yields(yield_arg1, yield_arg2) {return_value}
+    #   subject.method_name {|yield_arg1, yield_arg2|}
+    def yields(*args, &returns)
+      @yields = args
+      returns(&returns) if returns
+      self
+    end
+
+    # Scenario#after_call creates a callback that occurs after call
+    # is called. The passed in block receives the return value of
+    # the Scenario being called.
+    # An Expection will be raised if no block is passed in.
+    #
+    #   mock(subject).method_name {return_value}.after_call {|return_value|}
+    #   subject.method_name # return_value
+    #
+    # This feature is built into probes.
+    #   probe(User).find('1') {|user| mock(user).valid? {false}}
+    def after_call(&block)
+      raise ArgumentError, "after_call expects a block" unless block
+      @after_call = block
+      self
+    end
+    
     # Scenario#returns accepts an argument value or a block.
     # It will raise an ArgumentError if both are passed in.
     #
@@ -130,21 +162,6 @@ module RR
       end
     end
 
-    # Scenario#yields sets the Scenario to invoke a passed in block when
-    # the Scenario is called.
-    # An Expection will be raised if no block is passed in when the
-    # Scenario is called.
-    #
-    # Passing in a block sets the return value.
-    #
-    #   mock(subject).method_name.yields(yield_arg1, yield_arg2) {return_value}
-    #   subject.method_name {|yield_arg1, yield_arg2|}
-    def yields(*args, &returns)
-      @yields = args
-      returns(&returns) if returns
-      self
-    end
-
     # Scenario#implemented_by sets the implementation of the Scenario.
     # This method takes a Proc or a Method. Passing in a Method allows
     # the Scenario to accept blocks.
@@ -165,6 +182,12 @@ module RR
     # A TimesCalledError is raised when the times called
     # exceeds the expected TimesCalledExpectation.
     def call(*args, &block)
+      return_value = call_implementation(*args, &block)
+      @after_call.call(return_value) if @after_call
+      return_value
+    end
+
+    def call_implementation(*args, &block)
       @times_called_expectation.verify_input if @times_called_expectation
       @space.verify_ordered_scenario(self) if ordered?
       if @yields
@@ -182,6 +205,7 @@ module RR
         return @implementation.call(*args)
       end
     end
+    protected :call_implementation
 
     # Scenario#exact_match? returns true when the passed in arguments
     # exactly match the ArgumentEqualityError arguments.

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.3
 specification_version: 1
 name: rr
 version: !ruby/object:Gem::Version 
-  version: 0.1.5
-date: 2007-07-09 00:00:00 -07:00
+  version: 0.1.6
+date: 2007-07-10 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