rr 0.3.1 → 0.3.2

data/CHANGES

@@ -1,3 +1,6 @@
+* 0.3.2
+- Fixed [#12486] ScenarioMethodProxy when Kernel passed into instance methods
+
 * 0.3.1
 - Automatically require Test::Unit and Rspec adapters
 

data/Rakefile

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

data/examples/rr/scenario_creator_example.rb

@@ -21,6 +21,11 @@ describe ScenarioCreator, " strategy definition", :shared => true do
     scenario.should be_instance_of(Scenario)
   end
 
+  it "returns a ScenarioMethodProxy when passed Kernel" do
+    scenario = @creator.__send__(@method_name, Kernel).foobar
+    scenario.should be_instance_of(Scenario)
+  end
+
   it "raises error if passed a method name and a block" do
     proc do
       @creator.__send__(@method_name, @subject, :foobar) {}
@@ -203,9 +208,17 @@ describe ScenarioCreator, "#do_not_call" do
   end
 end
 
-describe ScenarioCreator, "#probe" do
+describe ScenarioCreator, "#probe and #stub" do
   it_should_behave_like "RR::ScenarioCreator"
 
+  before do
+    class << @subject
+      def foobar(*args)
+        :original_foobar
+      end
+    end
+  end
+
   it "raises error when using do_not_call strategy" do
     @creator.do_not_call
     proc do
@@ -216,30 +229,47 @@ describe ScenarioCreator, "#probe" do
     )
   end
 
-  it "sets up the RR stub call chain" do
-    should create_probe_call_chain(@creator.stub.probe(@subject))
-  end
-
-  it "creates a probe Scenario for method when passed a second argument" do
-    should create_scenario_with_method_name(@creator.stub.probe(@subject, :foobar))
-  end
-
-  def create_scenario_with_method_name(scenario)
-    method_name = scenario.method_name
-    scenario.with(1, 2) {:baz}
+  it "sets up the RR probe call chain" do
+    scenario = @creator.stub.probe(@subject).foobar(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
+    @subject.foobar(1, 2).should == :baz
   end
 
-  def create_probe_call_chain(creator)
-    scenario = creator.foobar(1, 2) {:baz}
+  it "creates a probe Scenario for method when passed a second argument" do
+    scenario = @creator.stub.probe(@subject, :foobar)
+    scenario.with(1, 2) {:baz}
     scenario.times_matcher.should == TimesCalledMatchers::AnyTimesMatcher.new
     scenario.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
     @subject.foobar(1, 2).should == :baz
   end
 end
 
+describe ScenarioCreator, "#instance_of" do
+  it_should_behave_like "RR::ScenarioCreator"
+
+  it "raises an error when not passed a class" #do
+#    proc do
+#      @creator.instance_of(Object.new)
+#    end.should raise_error(ArgumentError, "instance_of only accepts class objects")
+#  end
+
+  it "sets up the RR probe call chain" #do
+#    scenario = @creator.stub.instance_of(Class).foobar(1, 2) {:baz}
+#    scenario.times_matcher.should == TimesCalledMatchers::AnyTimesMatcher.new
+#    scenario.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
+#    Class.new.foobar(1, 2).should == :baz
+#  end
+
+  it "creates a probe Scenario for method when passed a second argument" #do
+#    scenario = @creator.stub.instance_of(Class, :foobar)
+#    scenario.with(1, 2) {:baz}
+#    scenario.times_matcher.should == TimesCalledMatchers::AnyTimesMatcher.new
+#    scenario.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
+#    Class.new.foobar(1, 2).should == :baz
+#  end
+end
+
 describe ScenarioCreator, "#create! using no strategy" do
   it_should_behave_like "RR::ScenarioCreator"
 

data/examples/rr/scenario_example.rb

@@ -78,12 +78,12 @@ describe Scenario, "#never" do
 
   it "sets up a Times Called Expectation with 0" do
     @scenario.never
-    proc {@scenario.call}.should raise_error(Errors::TimesCalledError)
+    proc {@scenario.call(@double)}.should raise_error(Errors::TimesCalledError)
   end
 
   it "sets return value when block passed in" do
     @scenario.with_any_args.never
-    proc {@scenario.call}.should raise_error(Errors::TimesCalledError)
+    proc {@scenario.call(@double)}.should raise_error(Errors::TimesCalledError)
   end
 end
 
@@ -92,8 +92,8 @@ describe Scenario, "#once" do
 
   it "sets up a Times Called Expectation with 1" do
     @scenario.once.should === @scenario
-    @scenario.call
-    proc {@scenario.call}.should raise_error(Errors::TimesCalledError)
+    @scenario.call(@double)
+    proc {@scenario.call(@double)}.should raise_error(Errors::TimesCalledError)
   end
 
   it "sets return value when block passed in" do
@@ -107,9 +107,9 @@ describe Scenario, "#twice" do
 
   it "sets up a Times Called Expectation with 2" do
     @scenario.twice.should === @scenario
-    @scenario.call
-    @scenario.call
-    proc {@scenario.call}.should raise_error(Errors::TimesCalledError)
+    @scenario.call(@double)
+    @scenario.call(@double)
+    proc {@scenario.call(@double)}.should raise_error(Errors::TimesCalledError)
   end
 
   it "sets return value when block passed in" do
@@ -145,10 +145,10 @@ describe Scenario, "#at_most" do
 
   it "sets up a Times Called Expectation with 1" do
     @scenario.at_most(2)
-    @scenario.call
-    @scenario.call
+    @scenario.call(@double)
+    @scenario.call(@double)
     proc do
-      @scenario.call
+      @scenario.call(@double)
     end.should raise_error(
       Errors::TimesCalledError,
       "Called 3 times.\nExpected at most 2 times."
@@ -166,10 +166,10 @@ describe Scenario, "#times" do
 
   it "sets up a Times Called Expectation with passed in times" do
     @scenario.times(3).should === @scenario
-    @scenario.call
-    @scenario.call
-    @scenario.call
-    proc {@scenario.call}.should raise_error(Errors::TimesCalledError)
+    @scenario.call(@double)
+    @scenario.call(@double)
+    @scenario.call(@double)
+    proc {@scenario.call(@double)}.should raise_error(Errors::TimesCalledError)
   end
 
   it "sets return value when block passed in" do
@@ -271,7 +271,7 @@ describe Scenario, "#after_call" do
       value
     end
 
-    actual_value = @scenario.call
+    actual_value = @scenario.call(@double)
     actual_value.should === return_value
     actual_value.should == {:foo => :bar}
   end
@@ -282,7 +282,7 @@ describe Scenario, "#after_call" do
       :after_call_value
     end
 
-    actual_value = @scenario.call
+    actual_value = @scenario.call(@double)
     actual_value.should == :after_call_value
   end
 
@@ -313,17 +313,17 @@ describe Scenario, "#returns" do
 
   it "sets the value of the method when passed a block" do
     @scenario.returns {:baz}
-    @scenario.call.should == :baz
+    @scenario.call(@double).should == :baz
   end
 
   it "sets the value of the method when passed an argument" do
     @scenario.returns(:baz)
-    @scenario.call.should == :baz
+    @scenario.call(@double).should == :baz
   end
 
   it "returns false when passed false" do
     @scenario.returns(false)
-    @scenario.call.should == false
+    @scenario.call(@double).should == false
   end
 
   it "raises an error when both argument and block is passed in" do
@@ -342,7 +342,7 @@ describe Scenario, "#implemented_by" do
 
   it "sets the implementation to the passed in proc" do
     @scenario.implemented_by(proc{:baz})
-    @scenario.call.should == :baz
+    @scenario.call(@double).should == :baz
   end
 
   it "sets the implementation to the passed in method" do
@@ -350,7 +350,7 @@ describe Scenario, "#implemented_by" do
       [b, a]
     end
     @scenario.implemented_by(@object.method(:foobar))
-    @scenario.call(1, 2).should == [2, 1]
+    @scenario.call(@double, 1, 2).should == [2, 1]
   end
 end
 
@@ -363,7 +363,21 @@ describe Scenario, "#implemented_by_original_method" do
 
   it "sets the implementation to the original method" do
     @scenario.implemented_by_original_method
-    @scenario.call(1, 2).should == [2, 1]
+    @scenario.call(@double, 1, 2).should == [2, 1]
+  end
+
+  it "raises error when original_method does not exist" do
+    double = @space.double(@object, :does_not_exist)
+    scenario = @space.scenario(double)
+    scenario.with_any_args
+    scenario.implemented_by_original_method
+
+    proc do
+      @object.does_not_exist(1, 2)
+    end.should raise_error(
+      Errors::ScenarioDefinitionError,
+      "implemented_by_original_method (probe) cannot be used when method does not exist on the object"
+    )
   end
 end
 
@@ -372,31 +386,31 @@ describe Scenario, "#call implemented by a proc" do
   
   it "calls the return proc when implemented by a proc" do
     @scenario.returns {|arg| "returning #{arg}"}
-    @scenario.call(:foobar).should == "returning foobar"
+    @scenario.call(@double, :foobar).should == "returning foobar"
   end
 
   it "calls and returns the after_call when after_call is set" do
     @scenario.returns {|arg| "returning #{arg}"}.after_call do |value|
       "#{value} after call"
     end
-    @scenario.call(:foobar).should == "returning foobar after call"
+    @scenario.call(@double, :foobar).should == "returning foobar after call"
   end
 
   it "returns nil when to returns is not set" do
-    @scenario.call.should be_nil
+    @scenario.call(@double).should be_nil
   end
 
   it "works when times_called is not set" do
     @scenario.returns {:value}
-    @scenario.call
+    @scenario.call(@double)
   end
 
   it "verifes the times_called does not exceed the TimesCalledExpectation" do
     @scenario.times(2).returns {:value}
 
-    @scenario.call(:foobar)
-    @scenario.call(:foobar)
-    proc {@scenario.call(:foobar)}.should raise_error(Errors::TimesCalledError)
+    @scenario.call(@double, :foobar)
+    @scenario.call(@double, :foobar)
+    proc {@scenario.call(@double, :foobar)}.should raise_error(Errors::TimesCalledError)
   end
 
   it "raises ScenarioOrderError when ordered and called out of order" do
@@ -428,7 +442,7 @@ describe Scenario, "#call implemented by a proc" do
     end
 
     @scenario.returns {:value}.ordered
-    @scenario.call(:foobar)
+    @scenario.call(@double, :foobar)
     verify_ordered_scenario_called.should be_true
     passed_in_scenario.should === @scenario
   end
@@ -443,7 +457,7 @@ describe Scenario, "#call implemented by a proc" do
     end
 
     @scenario.returns {:value}
-    @scenario.call(:foobar)
+    @scenario.call(@double, :foobar)
     verify_ordered_scenario_called.should be_false
   end
 
@@ -543,15 +557,15 @@ describe Scenario, "#attempt?" do
 
   it "returns true when TimesCalledExpectation#attempt? is true" do
     @scenario.with(1, 2, 3).twice
-    @scenario.call(1, 2, 3)
+    @scenario.call(@double, 1, 2, 3)
     @scenario.times_called_expectation.should be_attempt
     @scenario.should be_attempt
   end
 
   it "returns false when TimesCalledExpectation#attempt? is true" do
     @scenario.with(1, 2, 3).twice
-    @scenario.call(1, 2, 3)
-    @scenario.call(1, 2, 3)
+    @scenario.call(@double, 1, 2, 3)
+    @scenario.call(@double, 1, 2, 3)
     @scenario.times_called_expectation.should_not be_attempt
     @scenario.should_not be_attempt
   end
@@ -570,18 +584,18 @@ describe Scenario, "#verify" do
     @scenario.twice.returns {:return_value}
 
     proc {@scenario.verify}.should raise_error(Errors::TimesCalledError)
-    @scenario.call
+    @scenario.call(@double)
     proc {@scenario.verify}.should raise_error(Errors::TimesCalledError)
-    @scenario.call
+    @scenario.call(@double)
     
     proc {@scenario.verify}.should_not raise_error
   end
 
   it "does not raise an error when there is no times called expectation" do
     proc {@scenario.verify}.should_not raise_error
-    @scenario.call
+    @scenario.call(@double)
     proc {@scenario.verify}.should_not raise_error
-    @scenario.call
+    @scenario.call(@double)
     proc {@scenario.verify}.should_not raise_error
   end
 end

data/lib/rr/double.rb

@@ -74,7 +74,7 @@ module RR
 
     def call_method(args, block)
       if scenario = find_scenario_to_attempt(args)
-        return scenario.call(*args, &block)
+        return scenario.call(self, *args, &block)
       end
       scenario_not_found_error(*args)
     end

data/lib/rr/scenario.rb

@@ -15,6 +15,7 @@ module RR
         end.join("\n")
       end
     end
+    ORIGINAL_METHOD = Object.new
 
     attr_reader :times_called, :argument_expectation, :times_called_expectation, :double
 
@@ -247,7 +248,7 @@ module RR
     #   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
+      implemented_by ORIGINAL_METHOD
       self
     end
 
@@ -256,23 +257,36 @@ module RR
     #
     # A TimesCalledError is raised when the times called
     # exceeds the expected TimesCalledExpectation.
-    def call(*args, &block)
-      return_value = call_implementation(*args, &block)
+    def call(double, *args, &block)
+      @times_called_expectation.attempt! if @times_called_expectation
+      @space.verify_ordered_scenario(self) if ordered?
+      yields!(block)
+      return_value = call_implementation(double, *args, &block)
       return return_value unless @after_call
       @after_call.call(return_value)
     end
 
-    def call_implementation(*args, &block)
-      @times_called_expectation.attempt! if @times_called_expectation
-      @space.verify_ordered_scenario(self) if ordered?
+    def yields!(block)
       if @yields
         unless block
           raise ArgumentError, "A Block must be passed into the method call when using yields"
         end
         block.call(*@yields)
       end
+    end
+    protected :yields!
+
+    def call_implementation(double, *args, &block)
       return nil unless @implementation
 
+      if @implementation === ORIGINAL_METHOD
+        if !double.original_method
+          raise Errors::ScenarioDefinitionError,
+                "implemented_by_original_method (probe) cannot be used when method does not exist on the object"
+        end
+        return double.original_method.call(*args, &block)
+      end
+
       if @implementation.is_a?(Method)
         return @implementation.call(*args, &block)
       else

data/lib/rr/scenario_creator.rb

@@ -16,6 +16,7 @@ module RR
       @space = space
       @strategy = nil
       @probe = false
+      @instance_of = nil
     end
     
     def create!(subject, method_name, *args, &handler)
@@ -29,6 +30,13 @@ module RR
       @scenario
     end
 
+#    def instance_of(subject=NO_SUBJECT_ARG, method_name=nil, &definition)
+#      return self if subject === NO_SUBJECT_ARG
+#      raise ArgumentError, "instance_of only accepts class objects" unless subject.is_a?(Class)
+#      @instance_of = true
+#      RR::Space.scenario_method_proxy(self, subject, method_name, &definition)
+#    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
@@ -59,7 +67,7 @@ module RR
     def mock(subject=NO_SUBJECT_ARG, method_name=nil, &definition)
       strategy_error! if @strategy
       @strategy = :mock
-      return self if subject === NO_SUBJECT_ARG
+      return self if subject.__id__ === NO_SUBJECT_ARG.__id__
       RR::Space.scenario_method_proxy(self, subject, method_name, &definition)
     end
 
@@ -94,15 +102,31 @@ module RR
     def stub(subject=NO_SUBJECT_ARG, method_name=nil, &definition)
       strategy_error! if @strategy
       @strategy = :stub
-      return self if subject === NO_SUBJECT_ARG
+      return self if subject.__id__ === NO_SUBJECT_ARG.__id__
       RR::Space.scenario_method_proxy(self, subject, method_name, &definition)
     end
 
+    # 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=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
+      return self if subject.__id__ === NO_SUBJECT_ARG.__id__
       RR::Space.scenario_method_proxy(self, subject, method_name, &definition)
     end
     alias_method :dont_call, :do_not_call
@@ -157,7 +181,7 @@ module RR
     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
+      return self if subject.__id__ === NO_SUBJECT_ARG.__id__
       RR::Space.scenario_method_proxy(self, subject, method_name, &definition)
     end
     

metadata

@@ -3,7 +3,7 @@ rubygems_version: 0.9.3
 specification_version: 1
 name: rr
 version: !ruby/object:Gem::Version 
-  version: 0.3.1
+  version: 0.3.2
 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: