rr 0.2.5 → 0.3.0

data/examples/rr/scenario_example.rb

@@ -5,9 +5,11 @@ describe Scenario, :shared => true do
   before do
     @space = Space.new
     @object = Object.new
-    @method_name = :foobar
-    @double = @space.create_double(@object, @method_name)
-    @scenario = @space.create_scenario(@double)
+    def @object.foobar(a, b)
+      [b, a]
+    end
+    @double = @space.double(@object, :foobar)
+    @scenario = @space.scenario(@double)
   end
 end
 
@@ -352,6 +354,19 @@ describe Scenario, "#implemented_by" do
   end
 end
 
+describe Scenario, "#implemented_by_original_method" do
+  it_should_behave_like "RR::Scenario"
+
+  it "returns the scenario object" do
+    @scenario.implemented_by_original_method.should === @scenario
+  end
+
+  it "sets the implementation to the original method" do
+    @scenario.implemented_by_original_method
+    @scenario.call(1, 2).should == [2, 1]
+  end
+end
+
 describe Scenario, "#call implemented by a proc" do
   it_should_behave_like "RR::Scenario"
   
@@ -386,7 +401,7 @@ describe Scenario, "#call implemented by a proc" do
 
   it "raises ScenarioOrderError when ordered and called out of order" do
     scenario1 = @scenario
-    scenario2 = @space.create_scenario(@double)
+    scenario2 = @space.scenario(@double)
 
     scenario1.with(1).returns {:return_1}.ordered.once
     scenario2.with(2).returns {:return_2}.ordered.once

data/examples/rr/scenario_method_proxy_example.rb

@@ -0,0 +1,71 @@
+require "examples/example_helper"
+
+module RR
+describe ScenarioMethodProxy, :shared => true do
+  before(:each) do
+    @space = Space.new
+    @subject = Object.new
+    @creator = @space.scenario_creator
+    @creator.mock
+  end
+
+  it "initializes proxy with passed in creator" do
+    class << @proxy
+      attr_reader :creator
+    end
+    @proxy.creator.should === @creator
+  end
+end
+
+describe ScenarioMethodProxy, ".new without block" do
+  it_should_behave_like "RR::ScenarioMethodProxy"
+
+  before do
+    @proxy = ScenarioMethodProxy.new(@space, @creator, @subject)
+  end
+
+  it "clears out all methods from proxy" do
+    proxy_subclass = Class.new(ScenarioMethodProxy) do
+      def i_should_be_a_scenario
+      end
+    end
+    proxy_subclass.instance_methods.should include('i_should_be_a_scenario')
+
+    proxy = proxy_subclass.new(@space, @creator, @subject)
+    proxy.i_should_be_a_scenario.should be_instance_of(Scenario)
+  end
+end
+
+describe ScenarioMethodProxy, ".new with block" do
+  it_should_behave_like "RR::ScenarioMethodProxy"
+
+  before do
+    @proxy = ScenarioMethodProxy.new(@space, @creator, @subject) do |b|
+      b.foobar(1, 2) {:one_two}
+      b.foobar(1) {:one}
+      b.foobar.with_any_args {:default}
+      b.baz() {:baz_result}
+    end
+  end
+
+  it "creates doubles" do
+    @subject.foobar(1, 2).should == :one_two
+    @subject.foobar(1).should == :one
+    @subject.foobar(:something).should == :default
+    @subject.baz.should == :baz_result
+  end
+
+  it "clears out all methods from proxy" do
+    proxy_subclass = Class.new(ScenarioMethodProxy) do
+      def i_should_be_a_scenario
+      end
+    end
+    proxy_subclass.instance_methods.should include('i_should_be_a_scenario')
+
+    proxy_subclass.new(@space, @creator, @subject) do |m|
+      m.i_should_be_a_scenario.should be_instance_of(Scenario)
+    end
+  end
+end
+
+end

data/examples/rr/space/space_create_example.rb

@@ -1,7 +1,7 @@
 require "examples/example_helper"
 
 module RR
-describe Space, "#mock_creator" do
+describe Space, "#scenario_method_proxy", :shared => true do
   it_should_behave_like "RR::Space"
 
   before do
@@ -9,27 +9,50 @@ describe Space, "#mock_creator" do
     @object = Object.new
   end
 
-  it "creates a MockCreator" do
-    creator = @space.mock_creator(@object)
-    creator.foobar(1) {:baz}
-    @object.foobar(1).should == :baz
-    proc {@object.foobar(1)}.should raise_error(Errors::TimesCalledError)
+  it "creates a ScenarioMethodProxy" do
+    proxy = @space.scenario_method_proxy(@creator, @object)
+    proxy.should be_instance_of(ScenarioMethodProxy)
   end
 
-  it "creates a mock Scenario for method when passed a second argument" do
-    creator = @space.mock_creator(@object, :foobar).with(1) {:baz}
-    @object.foobar(1).should == :baz
-    proc {@object.foobar(1)}.should raise_error(Errors::TimesCalledError)
+  it "sets space to self" do
+    proxy = @space.scenario_method_proxy(@creator, @object)
+    class << proxy
+      attr_reader :space
+    end
+    proxy.space.should === @space
+  end
+
+  it "sets creator to passed in creator" do
+    proxy = @space.scenario_method_proxy(@creator, @object)
+    class << proxy
+      attr_reader :creator
+    end
+    proxy.creator.should === @creator
   end
 
   it "raises error if passed a method name and a block" do
     proc do
-      @space.mock_creator(@object, :foobar) {}
+      @space.scenario_method_proxy(@creator, @object, :foobar) {}
     end.should raise_error(ArgumentError, "Cannot pass in a method name and a block")
   end
+end
+
+describe Space, "#scenario_method_proxy with a Mock strategy" do
+  it_should_behave_like "RR::Space#scenario_method_proxy"
+
+  before do
+    @creator = @space.scenario_creator
+    @creator.mock
+  end
+
+  it "creates a mock Scenario for method when passed a second argument" do
+    @space.scenario_method_proxy(@creator, @object, :foobar).with(1) {:baz}
+    @object.foobar(1).should == :baz
+    proc {@object.foobar(1)}.should raise_error(Errors::TimesCalledError)
+  end
 
   it "uses block definition when passed a block" do
-    creator = @space.mock_creator(@object) do |c|
+    @space.scenario_method_proxy(@creator, @object) do |c|
       c.foobar(1) {:baz}
     end
     @object.foobar(1).should == :baz
@@ -37,36 +60,22 @@ describe Space, "#mock_creator" do
   end
 end
 
-describe Space, "#stub_creator" do
-  it_should_behave_like "RR::Space"
+describe Space, "#scenario_method_proxy with a Stub strategy" do
+  it_should_behave_like "RR::Space#scenario_method_proxy"
 
   before do
-    @space = Space.new
-    @object = Object.new
-    @method_name = :foobar
-  end
-
-  it "creates a StubCreator" do
-    creator = @space.stub_creator(@object)
-    creator.foobar {:baz}
-    @object.foobar.should == :baz
-    @object.foobar.should == :baz
+    @creator = @space.scenario_creator
+    @creator.stub
   end
 
   it "creates a stub Scenario for method when passed a second argument" do
-    creator = @space.stub_creator(@object, :foobar).with(1) {:baz}
+    @space.scenario_method_proxy(@creator, @object, :foobar).with(1) {:baz}
     @object.foobar(1).should == :baz
     @object.foobar(1).should == :baz
   end
 
-  it "raises error if passed a method name and a block" do
-    proc do
-      @space.stub_creator(@object, :foobar) {}
-    end.should raise_error(ArgumentError, "Cannot pass in a method name and a block")
-  end
-
   it "uses block definition when passed a block" do
-    creator = @space.stub_creator(@object) do |c|
+    @space.scenario_method_proxy(@creator, @object) do |c|
       c.foobar(1) {:return_value}
       c.foobar.with_any_args {:default}
       c.baz(1) {:baz_value}
@@ -77,39 +86,25 @@ describe Space, "#stub_creator" do
   end
 end
 
-describe Space, "#mock_probe_creator" do
-  it_should_behave_like "RR::Space"
+describe Space, "#scenario_method_proxy with a Mock Probe strategy" do
+  it_should_behave_like "RR::Space#scenario_method_proxy"
 
   before do
-    @space = Space.new
-    @object = Object.new
-    @method_name = :foobar
+    @creator = @space.scenario_creator
+    @creator.mock.probe
     def @object.foobar(*args)
       :original_foobar
     end
   end
 
-  it "creates a MockProbeCreator" do
-    creator = @space.mock_probe_creator(@object)
-    creator.foobar(1)
-    @object.foobar(1).should == :original_foobar
-    proc {@object.foobar(1)}.should raise_error(Errors::TimesCalledError)
-  end
-
   it "creates a mock probe Scenario for method when passed a second argument" do
-    creator = @space.mock_probe_creator(@object, :foobar).with(1)
+    @space.scenario_method_proxy(@creator, @object, :foobar).with(1)
     @object.foobar(1).should == :original_foobar
     proc {@object.foobar(1)}.should raise_error(Errors::TimesCalledError)
   end
 
-  it "raises error if passed a method name and a block" do
-    proc do
-      @space.mock_probe_creator(@object, :foobar) {}
-    end.should raise_error(ArgumentError, "Cannot pass in a method name and a block")
-  end
-
   it "uses block definition when passed a block" do
-    creator = @space.mock_probe_creator(@object) do |c|
+    @space.scenario_method_proxy(@creator, @object) do |c|
       c.foobar(1)
     end
     @object.foobar(1).should == :original_foobar
@@ -117,39 +112,25 @@ describe Space, "#mock_probe_creator" do
   end
 end
 
-describe Space, "#stub_probe_creator" do
-  it_should_behave_like "RR::Space"
+describe Space, "#scenario_method_proxy with a Stub Probe strategy" do
+  it_should_behave_like "RR::Space#scenario_method_proxy"
 
   before do
-    @space = Space.new
-    @object = Object.new
-    @method_name = :foobar
+    @creator = @space.scenario_creator
+    @creator.stub.probe
     def @object.foobar(*args)
       :original_foobar
     end
   end
 
-  it "creates a StubProbeCreator" do
-    creator = @space.stub_probe_creator(@object)
-    creator.foobar
-    @object.foobar(1).should == :original_foobar
-    @object.foobar(1).should == :original_foobar
-  end
-
   it "creates a stub probe Scenario for method when passed a second argument" do
-    creator = @space.stub_probe_creator(@object, :foobar)
+    @space.scenario_method_proxy(@creator, @object, :foobar)
     @object.foobar(1).should == :original_foobar
     @object.foobar(1).should == :original_foobar
   end
 
-  it "raises error if passed a method name and a block" do
-    proc do
-      @space.stub_probe_creator(@object, :foobar) {}
-    end.should raise_error(ArgumentError, "Cannot pass in a method name and a block")
-  end
-
   it "uses block definition when passed a block" do
-    creator = @space.stub_probe_creator(@object) do |c|
+    @space.scenario_method_proxy(@creator, @object) do |c|
       c.foobar(1)
     end
     @object.foobar(1).should == :original_foobar
@@ -157,40 +138,46 @@ describe Space, "#stub_probe_creator" do
   end
 end
 
-describe Space, "#do_not_allow_creator" do
-  it_should_behave_like "RR::Space"
+describe Space, "#scenario_method_proxy with a Do Not Allow strategy" do
+  it_should_behave_like "RR::Space#scenario_method_proxy"
 
   before do
-    @space = Space.new
-    @object = Object.new
-  end
-
-  it "creates a MockCreator" do
-    creator = @space.do_not_allow_creator(@object)
-    creator.foobar(1)
-    proc {@object.foobar(1)}.should raise_error(Errors::TimesCalledError)
+    @creator = @space.scenario_creator
+    @creator.do_not_call
   end
 
   it "creates a do not allow Scenario for method when passed a second argument" do
-    creator = @space.do_not_allow_creator(@object, :foobar).with(1)
+    @space.scenario_method_proxy(@creator, @object, :foobar).with(1)
     proc {@object.foobar(1)}.should raise_error(Errors::TimesCalledError)
   end
 
-  it "raises error if passed a method name and a block" do
-    proc do
-      @space.do_not_allow_creator(@object, :foobar) {}
-    end.should raise_error(ArgumentError, "Cannot pass in a method name and a block")
-  end
-
   it "uses block definition when passed a block" do
-    creator = @space.do_not_allow_creator(@object) do |c|
+    @space.scenario_method_proxy(@creator, @object) do |c|
       c.foobar(1)
     end
     proc {@object.foobar(1)}.should raise_error(Errors::TimesCalledError)
   end
 end
 
-describe Space, "#create_scenario" do
+describe Space, "#scenario_creator" do
+  it_should_behave_like "RR::Space"
+
+  before do
+    @space = Space.new
+    @object = Object.new
+    @creator = @space.scenario_creator
+  end
+
+  it "sets the space" do
+    @creator.space.should === @space
+  end
+
+  it "creates a ScenarioCreator" do
+    @creator.should be_instance_of(ScenarioCreator)
+  end
+end
+
+describe Space, "#scenario" do
   it_should_behave_like "RR::Space"
 
   before do
@@ -200,17 +187,17 @@ describe Space, "#create_scenario" do
   end
 
   it "creates a Scenario and registers it to the double" do
-    double = @space.create_double(@object, @method_name)
+    double = @space.double(@object, @method_name)
     def double.scenarios
       @scenarios
     end
 
-    scenario = @space.create_scenario(double)
+    scenario = @space.scenario(double)
     double.scenarios.should include(scenario)
   end
 end
 
-describe Space, "#create_double" do
+describe Space, "#double" do
   it_should_behave_like "RR::Space"
 
   before do
@@ -223,14 +210,14 @@ describe Space, "#create_double" do
     (object1 === object2).should be_true
     object1.__id__.should_not == object2.__id__
 
-    double1 = @space.create_double(object1, :foobar)
-    double2 = @space.create_double(object2, :foobar)
+    double1 = @space.double(object1, :foobar)
+    double2 = @space.double(object2, :foobar)
     
     double1.should_not == double2
   end
 end
 
-describe Space, "#create_double when double does not exist" do
+describe Space, "#double when double does not exist" do
   it_should_behave_like "RR::Space"
 
   before do
@@ -243,28 +230,28 @@ describe Space, "#create_double when double does not exist" do
   end
 
   it "returns double and adds double to double list when method_name is a symbol" do
-    double = @space.create_double(@object, @method_name)
-    @space.doubles[@object][@method_name].should === double
+    double = @space.double(@object, @method_name)
+    @space.double(@object, @method_name).should === double
     double.space.should === @space
     double.object.should === @object
     double.method_name.should === @method_name
   end
 
   it "returns double and adds double to double list when method_name is a string" do
-    double = @space.create_double(@object, 'foobar')
-    @space.doubles[@object][@method_name].should === double
+    double = @space.double(@object, 'foobar')
+    @space.double(@object, @method_name).should === double
     double.space.should === @space
     double.object.should === @object
     double.method_name.should === @method_name
   end
 
   it "overrides the method when passing a block" do
-    double = @space.create_double(@object, @method_name)
+    double = @space.double(@object, @method_name)
     @object.methods.should include("__rr__#{@method_name}")
   end
 end
 
-describe Space, "#create_double when double exists" do
+describe Space, "#double when double exists" do
   it_should_behave_like "RR::Space"
 
   before do
@@ -278,14 +265,14 @@ describe Space, "#create_double when double exists" do
 
   it "returns the existing double" do
     original_foobar_method = @object.method(:foobar)
-    double = @space.create_double(@object, 'foobar')
+    double = @space.double(@object, 'foobar')
 
     double.original_method.should == original_foobar_method
 
-    @space.create_double(@object, 'foobar').should === double
+    @space.double(@object, 'foobar').should === double
 
     double.reset
     @object.foobar.should == :original_foobar
   end
 end
-end
+end