rr 0.2.5 → 0.3.0

data/lib/rr/scenario.rb

@@ -20,12 +20,12 @@ module RR
 
     def initialize(space, double)
       @space = space
+      @double = double
       @implementation = nil
       @argument_expectation = nil
       @times_called_expectation = nil
       @times_called = 0
       @after_call = nil
-      @double = double
       @yields = nil
     end
 
@@ -203,7 +203,7 @@ module RR
       @after_call = block
       self
     end
-    
+
     # Scenario#returns accepts an argument value or a block.
     # It will raise an ArgumentError if both are passed in.
     #
@@ -236,6 +236,21 @@ module RR
       self
     end
 
+    # Scenario#implemented_by_original_method sets the implementation
+    # of the Scenario to be the original method.
+    # This is primarily used with probes.
+    #
+    #   obj = Object.new
+    #   def obj.foobar
+    #     yield(1)
+    #   end
+    #   mock(obj).method_name.implemented_by_original_method
+    #   obj.foobar {|arg| puts arg} # puts 1
+    def implemented_by_original_method
+      implemented_by @double.original_method
+      self
+    end
+
     # Scenario#call calls the Scenario's implementation. The return
     # value of the implementation is returned.
     #
@@ -270,7 +285,7 @@ module RR
     # Scenario#exact_match? returns true when the passed in arguments
     # exactly match the ArgumentEqualityExpectation arguments.
     def exact_match?(*arguments)
-      return false unless @argument_expectation 
+      return false unless @argument_expectation
       @argument_expectation.exact_match?(*arguments)
     end
 

data/lib/rr/scenario_creator.rb

@@ -0,0 +1,233 @@
+module RR
+  # RR::ScenarioCreator provides a strategies to create a Scenario.
+  # The strategies are:
+  # * mock
+  # * stub
+  # * do_not_call
+  #
+  # Probing can also be added.
+  class ScenarioCreator
+    NO_SUBJECT_ARG = Object.new
+
+    attr_reader :space, :subject
+    include Errors
+
+    def initialize(space)
+      @space = space
+      @strategy = nil
+      @probe = false
+    end
+    
+    def create!(subject, method_name, *args, &handler)
+      @subject = subject
+      @method_name = method_name
+      @args = args
+      @handler = handler
+      @double = @space.double(@subject, method_name)
+      @scenario = @space.scenario(@double)
+      transform!
+      @scenario
+    end
+
+    # 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.
+    #   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(subject) do
+    #     method_name_1 {return_value_1}
+    #     method_name_2(arg_1, arg_2) {return_value_2}
+    #   end
+    def mock(subject=NO_SUBJECT_ARG, method_name=nil, &definition)
+      strategy_error! if @strategy
+      @strategy = :mock
+      return self if subject === NO_SUBJECT_ARG
+      RR::Space.scenario_method_proxy(self, subject, method_name, &definition)
+    end
+
+    # 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(subject) do
+    #     method_name_1 {return_value_1}
+    #     method_name_2(arg_1, arg_2) {return_value_2}
+    #   end
+    def stub(subject=NO_SUBJECT_ARG, method_name=nil, &definition)
+      strategy_error! if @strategy
+      @strategy = :stub
+      return self if subject === NO_SUBJECT_ARG
+      RR::Space.scenario_method_proxy(self, subject, method_name, &definition)
+    end
+
+    def do_not_call(subject=NO_SUBJECT_ARG, method_name=nil, &definition)
+      strategy_error! if @strategy
+      probe_when_do_not_call_error! if @probe
+      @strategy = :do_not_call
+      return self if subject === NO_SUBJECT_ARG
+      RR::Space.scenario_method_proxy(self, subject, method_name, &definition)
+    end
+    alias_method :dont_call, :do_not_call
+    alias_method :do_not_allow, :do_not_call
+    alias_method :dont_allow, :do_not_call
+
+    # This method add probe capabilities to the Scenario. probe can be called
+    # with mock or stub.
+    #
+    #   mock.probe(controller.template).render(:partial => "my/socks")
+    #
+    #   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|
+    #     html.should include("My socks are wet")
+    #     "My new return value"
+    #   end
+    #
+    # mock.probe also takes a block for definitions.
+    #   mock.probe(subject) 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.
+    #
+    #   mock.probe(controller.template).render(:partial => "my/socks") do |html|
+    #     html.should include("My socks are wet")
+    #     "My new return value"
+    #   end
+    def probe(subject=NO_SUBJECT_ARG, method_name=nil, &definition)
+      probe_when_do_not_call_error! if @strategy == :do_not_call
+      @probe = true
+      return self if subject === NO_SUBJECT_ARG
+      RR::Space.scenario_method_proxy(self, subject, method_name, &definition)
+    end
+    
+    protected
+    def transform!
+      case @strategy
+      when :mock; mock!
+      when :stub; stub!
+      when :do_not_call; do_not_call!
+      else no_strategy_error!
+      end
+      
+      if @probe
+        probe!
+      else
+        reimplementation!
+      end
+    end
+
+    def mock!
+      @scenario.with(*@args).once
+    end
+
+    def stub!
+      @scenario.any_number_of_times
+      permissive_argument!
+    end
+
+    def do_not_call!
+      @scenario.never
+      permissive_argument!
+      reimplementation!
+    end
+
+    def permissive_argument!
+      if @args.empty?
+        @scenario.with_any_args
+      else
+        @scenario.with(*@args)
+      end
+    end
+
+    def reimplementation!
+      @scenario.returns(&@handler)
+    end
+    
+    def probe!
+      @scenario.implemented_by_original_method
+      @scenario.after_call(&@handler) if @handler
+    end
+
+    def strategy_error!
+      raise(
+        ScenarioDefinitionError,
+        "This Scenario already has a #{@strategy} strategy"
+      )
+    end
+
+    def no_strategy_error!
+      raise(
+        ScenarioDefinitionError,
+        "This Scenario has no strategy"
+      )
+    end
+
+    def probe_when_do_not_call_error!
+      raise(
+        ScenarioDefinitionError,
+        "Scenarios cannot be probed when using do_not_call strategy"
+      )
+    end
+  end
+end

data/lib/rr/scenario_method_proxy.rb

@@ -0,0 +1,19 @@
+module RR
+  class ScenarioMethodProxy
+    def initialize(space, creator, object, &block)
+      @space = space
+      @creator = creator
+      @object = object
+      class << self
+        instance_methods.each do |m|
+          undef_method m unless m =~ /^__/
+        end
+
+        def method_missing(method_name, *args, &block)
+          @creator.create!(@object, method_name, *args, &block)
+        end
+      end
+      yield(self) if block_given?
+    end
+  end
+end

data/lib/rr/space.rb

@@ -25,33 +25,22 @@ module RR
       @trim_backtrace = false
     end
 
-    # Creates a MockCreator.
-    def mock_creator(subject, method_name=nil, &definition)
-      setup_creator MockCreator, subject, method_name, definition
-    end
-
-    # Creates a StubCreator.
-    def stub_creator(subject, method_name=nil, &definition)
-      setup_creator StubCreator, subject, method_name, definition
-    end
-
-    # Creates a MockProbeCreator.
-    def mock_probe_creator(subject, method_name=nil, &definition)
-      setup_creator MockProbeCreator, subject, method_name, definition
-    end
-
-    # Creates a StubProbeCreator.
-    def stub_probe_creator(subject, method_name=nil, &definition)
-      setup_creator StubProbeCreator, subject, method_name, definition
+    def scenario_method_proxy(creator, object, method_name=nil, &definition)
+      if method_name && definition
+        raise ArgumentError, "Cannot pass in a method name and a block"
+      end
+      proxy = ScenarioMethodProxy.new(self, creator, object, &definition)
+      return proxy unless method_name
+      proxy.__send__(method_name)
     end
 
-    # Creates a DoNotAllowCreator.
-    def do_not_allow_creator(subject, method_name=nil, &definition)
-      setup_creator DoNotAllowCreator, subject, method_name, definition
+    # Creates a ScenarioCreator.
+    def scenario_creator
+      ScenarioCreator.new(self)
     end
 
     # Creates and registers a Scenario to be verified.
-    def create_scenario(double)
+    def scenario(double)
       scenario = Scenario.new(self, double)
       double.register_scenario scenario
       scenario
@@ -61,7 +50,7 @@ module RR
     # in object and method_name.
     # When a Double is created, it binds the dispatcher to the
     # object.
-    def create_double(object, method_name)
+    def double(object, method_name)
       double = @doubles[object][method_name.to_sym]
       return double if double
 
@@ -124,15 +113,6 @@ 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.5
-date: 2007-07-21 00:00:00 -07:00
+  version: 0.3.0
+date: 2007-07-22 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
@@ -33,17 +33,13 @@ files:
 - CHANGES
 - README
 - lib/rr.rb
-- lib/rr/mock_probe_creator.rb
+- lib/rr/scenario_method_proxy.rb
 - lib/rr/scenario.rb
 - lib/rr/hash_with_object_id_key.rb
-- lib/rr/creator.rb
-- lib/rr/stub_probe_creator.rb
 - lib/rr/scenario_matches.rb
-- lib/rr/stub_creator.rb
 - lib/rr/space.rb
 - lib/rr/double.rb
-- lib/rr/do_not_allow_creator.rb
-- lib/rr/mock_creator.rb
+- lib/rr/scenario_creator.rb
 - lib/rr/times_called_matchers/any_times_matcher.rb
 - lib/rr/times_called_matchers/at_most_matcher.rb
 - lib/rr/times_called_matchers/times_called_matcher.rb
@@ -61,6 +57,7 @@ files:
 - lib/rr/errors/scenario_order_error.rb
 - lib/rr/errors/rr_error.rb
 - lib/rr/errors/times_called_error.rb
+- lib/rr/errors/scenario_definition_error.rb
 - lib/rr/adapters/test_unit.rb
 - lib/rr/adapters/rspec.rb
 - lib/rr/wildcard_matchers/boolean.rb
@@ -77,12 +74,9 @@ files:
 - examples/example_helper.rb
 - examples/test_unit_example_suite.rb
 - examples/high_level_example.rb
-- examples/rr/stub_probe_creator_example.rb
-- examples/rr/mock_creator_example.rb
-- examples/rr/stub_creator_example.rb
+- examples/rr/scenario_method_proxy_example.rb
 - examples/rr/scenario_example.rb
-- examples/rr/do_not_allow_creator_example.rb
-- examples/rr/mock_probe_creator_example.rb
+- examples/rr/scenario_creator_example.rb
 - examples/rr/rspec/rspec_backtrace_tweaking_example.rb
 - examples/rr/rspec/rspec_adapter_example.rb
 - examples/rr/rspec/rspec_usage_example.rb

data/examples/rr/do_not_allow_creator_example.rb

@@ -1,111 +0,0 @@
-require "examples/example_helper"
-
-module RR
-describe DoNotAllowCreator, :shared => true do
-  before(:each) do
-    @space = Space.new
-    @subject = Object.new
-  end
-
-  it "initializes creator with passed in object" do
-    class << @creator
-      attr_reader :subject
-    end
-    @creator.subject.should === @subject
-  end
-end
-
-describe DoNotAllowCreator, ".new" do
-  it_should_behave_like "RR::DoNotAllowCreator"
-
-  before do
-    @creator = DoNotAllowCreator.new(@space, @subject)
-  end
-
-  it "clears out all methods from creator" do
-    creator_subclass = Class.new(DoNotAllowCreator) do
-      def i_should_be_a_scenario
-      end
-    end
-    creator_subclass.instance_methods.should include('i_should_be_a_scenario')
-
-    creator = creator_subclass.new(@space, @subject)
-    creator.i_should_be_a_scenario.should be_instance_of(Scenario)
-  end
-end
-
-describe DoNotAllowCreator, ".new with block" do
-  it_should_behave_like "RR::DoNotAllowCreator"
-
-  before do
-    @creator = DoNotAllowCreator.new(@space, @subject) do |c|
-      c.any_args
-      c.no_args.with_no_args
-      c.with_args(1, 2)
-    end
-  end
-
-  it "raises TimesCalledError when any_args is called with no arguments" do
-    proc {@subject.any_args}.should raise_error(Errors::TimesCalledError)
-  end
-
-  it "raises TimesCalledError when any_args is called with arguments" do
-    proc {@subject.any_args(1, 2)}.should raise_error(Errors::TimesCalledError)
-  end
-
-  it "raises TimesCalledError when no_args is called with no arguments" do
-    proc {@subject.no_args}.should raise_error(Errors::TimesCalledError)
-  end
-
-  it "does not raise TimesCalledError when no_args is called with arguments" do
-    proc {@subject.no_args(1, 2)}.should raise_error(Errors::ScenarioNotFoundError)
-  end
-
-  it "raises TimesCalledError when any_args is called with no arguments" do
-    proc {@subject.with_args}.should raise_error(Errors::ScenarioNotFoundError)
-  end
-
-  it "raises TimesCalledError when any_args is called with arguments" do
-    proc {@subject.any_args(1, 2)}.should raise_error(Errors::TimesCalledError)
-  end
-
-  it "clears out all methods from creator" do
-    creator_subclass = Class.new(DoNotAllowCreator) do
-      def i_should_be_a_scenario
-      end
-    end
-    creator_subclass.instance_methods.should include('i_should_be_a_scenario')
-
-    creator = creator_subclass.new(@space, @subject)
-    creator.i_should_be_a_scenario.should be_instance_of(Scenario)
-  end
-end
-
-describe DoNotAllowCreator, "#method_missing" do
-  it_should_behave_like "RR::DoNotAllowCreator"
-
-  before do
-    @subject = Object.new
-    @creator = DoNotAllowCreator.new(@space, @subject)
-  end
-
-  it "sets expectation for method to never be called with any arguments when on arguments passed in" do
-    @creator.foobar
-    proc {@subject.foobar}.should raise_error(Errors::TimesCalledError)
-    proc {@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.foobar(1, 2)
-    proc {@subject.foobar}.should raise_error(Errors::ScenarioNotFoundError)
-    proc {@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.foobar.with_no_args
-    proc {@subject.foobar}.should raise_error(Errors::TimesCalledError)
-    proc {@subject.foobar(1, 2)}.should raise_error(Errors::ScenarioNotFoundError)
-  end
-end
-
-end