rr 0.4.2 → 0.4.3

data/spec/rr/adapters/rr_methods_creator_spec.rb

@@ -28,11 +28,11 @@ module RR
         end
 
         it "creates a mock Double for method when passed a second argument" do
-          creates_scenario_with_method_name(mock(@subject, :foobar))
+          creates_double_with_method_name(mock(@subject, :foobar))
         end
 
         it "creates a mock Double for method when passed a second argument with rr_mock" do
-          creates_scenario_with_method_name(rr_mock(@subject, :foobar))
+          creates_double_with_method_name(rr_mock(@subject, :foobar))
         end
 
         it "raises error if passed a method name and a block" do
@@ -41,20 +41,20 @@ module RR
           end.should raise_error(ArgumentError, "Cannot pass in a method name and a block")
         end
 
-        def creates_scenario_with_method_name(scenario)
-          scenario.with(1, 2) {:baz}
-          scenario.times_matcher.should == TimesCalledMatchers::IntegerMatcher.new(1)
-          scenario.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
-          scenario.argument_expectation.expected_arguments.should == [1, 2]
+        def creates_double_with_method_name(double)
+          double.with(1, 2) {:baz}
+          double.times_matcher.should == TimesCalledMatchers::IntegerMatcher.new(1)
+          double.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
+          double.argument_expectation.expected_arguments.should == [1, 2]
 
           @subject.foobar(1, 2).should == :baz
         end
 
         def creates_mock_call_chain(creator)
-          scenario = creator.foobar(1, 2) {:baz}
-          scenario.times_matcher.should == TimesCalledMatchers::IntegerMatcher.new(1)
-          scenario.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
-          scenario.argument_expectation.expected_arguments.should == [1, 2]
+          double = creator.foobar(1, 2) {:baz}
+          double.times_matcher.should == TimesCalledMatchers::IntegerMatcher.new(1)
+          double.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
+          double.argument_expectation.expected_arguments.should == [1, 2]
 
           @subject.foobar(1, 2).should == :baz
         end
@@ -85,11 +85,11 @@ module RR
         end
 
         it "creates a stub Double for method when passed a second argument" do
-          creates_scenario_with_method_name(stub(@subject, :foobar))
+          creates_double_with_method_name(stub(@subject, :foobar))
         end
 
         it "#rr_stub creates a stub Double for method when passed a second argument" do
-          creates_scenario_with_method_name(rr_stub(@subject, :foobar))
+          creates_double_with_method_name(rr_stub(@subject, :foobar))
         end
 
         it "raises error if passed a method name and a block" do
@@ -98,17 +98,17 @@ module RR
           end.should raise_error(ArgumentError, "Cannot pass in a method name and a block")
         end
 
-        def creates_scenario_with_method_name(scenario)
-          scenario.with(1, 2) {:baz}
-          scenario.times_matcher.should == TimesCalledMatchers::AnyTimesMatcher.new
-          scenario.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
+        def creates_double_with_method_name(double)
+          double.with(1, 2) {:baz}
+          double.times_matcher.should == TimesCalledMatchers::AnyTimesMatcher.new
+          double.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
           @subject.foobar(1, 2).should == :baz
         end
 
         def creates_stub_call_chain(creator)
-          scenario = creator.foobar(1, 2) {:baz}
-          scenario.times_matcher.should == TimesCalledMatchers::AnyTimesMatcher.new
-          scenario.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
+          double = creator.foobar(1, 2) {:baz}
+          double.times_matcher.should == TimesCalledMatchers::AnyTimesMatcher.new
+          double.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
           @subject.foobar(1, 2).should == :baz
         end
       end
@@ -146,19 +146,19 @@ module RR
         end
 
         it "#proxy creates a mock Double for method when passed a second argument" do
-          creates_scenario_with_method_name(mock.proxy(@subject, :foobar))
+          creates_double_with_method_name(mock.proxy(@subject, :foobar))
         end
 
         it "#rr_proxy creates a mock Double for method when passed a second argument with rr_mock" do
-          creates_scenario_with_method_name(rr_proxy.mock(@subject, :foobar))
+          creates_double_with_method_name(rr_proxy.mock(@subject, :foobar))
         end
 
         it "#mock_proxy creates a mock Double for method when passed a second argument" do
-          creates_scenario_with_method_name(mock.proxy(@subject, :foobar))
+          creates_double_with_method_name(mock.proxy(@subject, :foobar))
         end
 
         it "#rr_mock_proxy creates a mock Double for method when passed a second argument with rr_mock" do
-          creates_scenario_with_method_name(rr_mock.proxy(@subject, :foobar))
+          creates_double_with_method_name(rr_mock.proxy(@subject, :foobar))
         end
 
         it "raises error if passed a method name and a block" do
@@ -167,20 +167,20 @@ module RR
           end.should raise_error(ArgumentError, "Cannot pass in a method name and a block")
         end
 
-        def creates_scenario_with_method_name(scenario)
-          scenario.with(1, 2)
-          scenario.times_matcher.should == TimesCalledMatchers::IntegerMatcher.new(1)
-          scenario.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
-          scenario.argument_expectation.expected_arguments.should == [1, 2]
+        def creates_double_with_method_name(double)
+          double.with(1, 2)
+          double.times_matcher.should == TimesCalledMatchers::IntegerMatcher.new(1)
+          double.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
+          double.argument_expectation.expected_arguments.should == [1, 2]
 
           @subject.foobar(1, 2).should == :original_value
         end
 
         def creates_mock_proxy_call_chain(creator)
-          scenario = creator.foobar(1, 2)
-          scenario.times_matcher.should == TimesCalledMatchers::IntegerMatcher.new(1)
-          scenario.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
-          scenario.argument_expectation.expected_arguments.should == [1, 2]
+          double = creator.foobar(1, 2)
+          double.times_matcher.should == TimesCalledMatchers::IntegerMatcher.new(1)
+          double.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
+          double.argument_expectation.expected_arguments.should == [1, 2]
 
           @subject.foobar(1, 2).should == :original_value
         end
@@ -211,11 +211,11 @@ module RR
         end
 
         it "#stub.proxy creates a stub Double for method when passed a second argument" do
-          creates_scenario_with_method_name(stub.proxy(@subject, :foobar))
+          creates_double_with_method_name(stub.proxy(@subject, :foobar))
         end
 
         it "#rr_stub.proxy creates a stub Double for method when passed a second argument with rr_stub" do
-          creates_scenario_with_method_name(rr_stub.proxy(@subject, :foobar))
+          creates_double_with_method_name(rr_stub.proxy(@subject, :foobar))
         end
 
         it "raises error if passed a method name and a block" do
@@ -224,17 +224,17 @@ module RR
           end.should raise_error(ArgumentError, "Cannot pass in a method name and a block")
         end
 
-        def creates_scenario_with_method_name(scenario)
-          scenario.times_matcher.should == TimesCalledMatchers::AnyTimesMatcher.new
-          scenario.argument_expectation.class.should == RR::Expectations::AnyArgumentExpectation
+        def creates_double_with_method_name(double)
+          double.times_matcher.should == TimesCalledMatchers::AnyTimesMatcher.new
+          double.argument_expectation.class.should == RR::Expectations::AnyArgumentExpectation
 
           @subject.foobar(:something).should == :original_value
         end
 
         def creates_stub_proxy_call_chain(creator)
-          scenario = creator.foobar
-          scenario.times_matcher.should == TimesCalledMatchers::AnyTimesMatcher.new
-          scenario.argument_expectation.class.should == RR::Expectations::AnyArgumentExpectation
+          double = creator.foobar
+          double.times_matcher.should == TimesCalledMatchers::AnyTimesMatcher.new
+          double.argument_expectation.class.should == RR::Expectations::AnyArgumentExpectation
 
           @subject.foobar(1, 2).should == :original_value
         end
@@ -268,14 +268,14 @@ module RR
         end
 
         it "creates a mock Double for method when passed a second argument" do
-          creates_scenario_with_method_name(dont_allow(@subject, :foobar))
-          creates_scenario_with_method_name(rr_dont_allow(@subject, :foobar))
-          creates_scenario_with_method_name(dont_call(@subject, :foobar))
-          creates_scenario_with_method_name(rr_dont_call(@subject, :foobar))
-          creates_scenario_with_method_name(do_not_allow(@subject, :foobar))
-          creates_scenario_with_method_name(rr_do_not_allow(@subject, :foobar))
-          creates_scenario_with_method_name(dont_allow(@subject, :foobar))
-          creates_scenario_with_method_name(rr_dont_allow(@subject, :foobar))
+          creates_double_with_method_name(dont_allow(@subject, :foobar))
+          creates_double_with_method_name(rr_dont_allow(@subject, :foobar))
+          creates_double_with_method_name(dont_call(@subject, :foobar))
+          creates_double_with_method_name(rr_dont_call(@subject, :foobar))
+          creates_double_with_method_name(do_not_allow(@subject, :foobar))
+          creates_double_with_method_name(rr_do_not_allow(@subject, :foobar))
+          creates_double_with_method_name(dont_allow(@subject, :foobar))
+          creates_double_with_method_name(rr_dont_allow(@subject, :foobar))
         end
 
         it "raises error if passed a method name and a block" do
@@ -284,11 +284,11 @@ module RR
           end.should raise_error(ArgumentError, "Cannot pass in a method name and a block")
         end
 
-        def creates_scenario_with_method_name(scenario)
-          scenario.with(1, 2)
-          scenario.times_matcher.should == TimesCalledMatchers::IntegerMatcher.new(0)
-          scenario.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
-          scenario.argument_expectation.expected_arguments.should == [1, 2]
+        def creates_double_with_method_name(double)
+          double.with(1, 2)
+          double.times_matcher.should == TimesCalledMatchers::IntegerMatcher.new(0)
+          double.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
+          double.argument_expectation.expected_arguments.should == [1, 2]
 
           proc do
             @subject.foobar(1, 2)
@@ -298,10 +298,10 @@ module RR
         end
 
         def creates_do_not_allow_call_chain(creator)
-          scenario = creator.foobar(1, 2)
-          scenario.times_matcher.should == TimesCalledMatchers::IntegerMatcher.new(0)
-          scenario.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
-          scenario.argument_expectation.expected_arguments.should == [1, 2]
+          double = creator.foobar(1, 2)
+          double.times_matcher.should == TimesCalledMatchers::IntegerMatcher.new(0)
+          double.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
+          double.argument_expectation.expected_arguments.should == [1, 2]
 
           proc do
             @subject.foobar(1, 2)
@@ -329,11 +329,11 @@ module RR
         end
 
         it "creates a instance_of Double for method when passed a second argument" do
-          creates_scenario_with_method_name(instance_of.mock(@klass, :foobar))
+          creates_double_with_method_name(instance_of.mock(@klass, :foobar))
         end
 
         it "creates a instance_of Double for method when passed a second argument with rr_instance_of" do
-          creates_scenario_with_method_name(rr_instance_of.mock(@klass, :foobar))
+          creates_double_with_method_name(rr_instance_of.mock(@klass, :foobar))
         end
 
         it "raises error if passed a method name and a block" do
@@ -342,20 +342,20 @@ module RR
           end.should raise_error(ArgumentError, "Cannot pass in a method name and a block")
         end
 
-        def creates_scenario_with_method_name(scenario)
-          scenario.with(1, 2) {:baz}
-          scenario.times_matcher.should == TimesCalledMatchers::IntegerMatcher.new(1)
-          scenario.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
-          scenario.argument_expectation.expected_arguments.should == [1, 2]
+        def creates_double_with_method_name(double)
+          double.with(1, 2) {:baz}
+          double.times_matcher.should == TimesCalledMatchers::IntegerMatcher.new(1)
+          double.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
+          double.argument_expectation.expected_arguments.should == [1, 2]
 
           @klass.new.foobar(1, 2).should == :baz
         end
 
         def creates_instance_of_call_chain(creator)
-          scenario = creator.foobar(1, 2) {:baz}
-          scenario.times_matcher.should == TimesCalledMatchers::IntegerMatcher.new(1)
-          scenario.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
-          scenario.argument_expectation.expected_arguments.should == [1, 2]
+          double = creator.foobar(1, 2) {:baz}
+          double.times_matcher.should == TimesCalledMatchers::IntegerMatcher.new(1)
+          double.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
+          double.argument_expectation.expected_arguments.should == [1, 2]
 
           @klass.new.foobar(1, 2).should == :baz
         end

data/spec/rr/adapters/rr_methods_space_spec.rb

@@ -67,12 +67,12 @@ module RR
         end
 
         describe RRMethods, "#reset" do
-          it "#reset removes the ordered scenarios" do
-            removes_ordered_scenarios {reset}
+          it "#reset removes the ordered doubles" do
+            removes_ordered_doubles {reset}
           end
 
-          it "#rr_reset removes the ordered scenarios" do
-            removes_ordered_scenarios {rr_reset}
+          it "#rr_reset removes the ordered doubles" do
+            removes_ordered_doubles {rr_reset}
           end
 
           it "#reset resets all double_insertions" do
@@ -83,20 +83,20 @@ module RR
             resets_all_double_insertions {rr_reset}
           end
 
-          def removes_ordered_scenarios
+          def removes_ordered_doubles
             double1 = @space.double_insertion(@object1, :foobar1)
             double2 = @space.double_insertion(@object1, :foobar2)
 
-            scenario1 = @space.scenario(double1)
-            scenario2 = @space.scenario(double2)
+            double1 = @space.double(double1)
+            double2 = @space.double(double2)
 
-            scenario1.ordered
-            scenario2.ordered
+            double1.ordered
+            double2.ordered
 
-            @space.ordered_scenarios.should_not be_empty
+            @space.ordered_doubles.should_not be_empty
 
             yield
-            @space.ordered_scenarios.should be_empty
+            @space.ordered_doubles.should be_empty
           end
 
           def resets_all_double_insertions

data/spec/rr/double/double_injection_dispatching_spec.rb

@@ -14,7 +14,7 @@ module RR
         :foobar
       end
 
-      describe "where the scenario takes a block" do
+      describe "where the double takes a block" do
         it "executes the block" do
           method_fixture = Object.new
           class << method_fixture
@@ -22,43 +22,43 @@ module RR
               yield(a, b)
             end
           end
-          scenario = @space.scenario(@double_insertion)
-          scenario.with(1, 2).implemented_by(method_fixture.method(:method_with_block))
+          double = @space.double(@double_insertion)
+          double.with(1, 2).implemented_by(method_fixture.method(:method_with_block))
           @object.foobar(1, 2) {|a, b| [b, a]}.should == [2, 1]
         end
       end
 
-      describe "where there are no scenarios with duplicate ArgumentExpectations" do
+      describe "where there are no doubles with duplicate ArgumentExpectations" do
         it "dispatches to Double that have an exact match" do
-          scenario1_with_exact_match = @space.scenario(@double_insertion)
-          scenario1_with_exact_match.with(:exact_match_1).returns {:return_1}
-          scenario_with_no_match = @space.scenario(@double_insertion)
-          scenario_with_no_match.with("nothing that matches").returns {:no_match}
-          scenario2_with_exact_match = @space.scenario(@double_insertion)
-          scenario2_with_exact_match.with(:exact_match_2).returns {:return_2}
+          double1_with_exact_match = @space.double(@double_insertion)
+          double1_with_exact_match.with(:exact_match_1).returns {:return_1}
+          double_with_no_match = @space.double(@double_insertion)
+          double_with_no_match.with("nothing that matches").returns {:no_match}
+          double2_with_exact_match = @space.double(@double_insertion)
+          double2_with_exact_match.with(:exact_match_2).returns {:return_2}
 
           @object.foobar(:exact_match_1).should == :return_1
           @object.foobar(:exact_match_2).should == :return_2
         end
 
         it "dispatches to Double that have a wildcard match" do
-          scenario_with_wildcard_match = @space.scenario(@double_insertion)
-          scenario_with_wildcard_match.with_any_args.returns {:wild_card_value}
-          scenario_with_no_match = @space.scenario(@double_insertion)
-          scenario_with_no_match.with("nothing that matches").returns {:no_match}
+          double_with_wildcard_match = @space.double(@double_insertion)
+          double_with_wildcard_match.with_any_args.returns {:wild_card_value}
+          double_with_no_match = @space.double(@double_insertion)
+          double_with_no_match.with("nothing that matches").returns {:no_match}
 
           @object.foobar(:wildcard_match_1).should == :wild_card_value
           @object.foobar(:wildcard_match_2, 3).should == :wild_card_value
         end
       end
 
-      describe "where there are scenarios" do
-        it "raises DoubleNotFoundError error when arguments do not match a scenario" do
-          scenario_1 = @space.scenario(@double_insertion)
-          scenario_1.with(1, 2)
+      describe "where there are doubles" do
+        it "raises DoubleNotFoundError error when arguments do not match a double" do
+          double_1 = @space.double(@double_insertion)
+          double_1.with(1, 2)
 
-          scenario_2 = @space.scenario(@double_insertion)
-          scenario_2.with(3)
+          double_2 = @space.double(@double_insertion)
+          double_2.with(3)
 
           proc {@object.foobar(:arg1, :arg2)}.should raise_error(
           Errors::DoubleNotFoundError,
@@ -71,70 +71,70 @@ module RR
 
       describe "where there are Doubles with NonTerminal TimesCalledMatchers" do
         it "dispatches to Double with exact match" do
-          scenario = scenario(1, 2) {:return_value}
+          double = double(1, 2) {:return_value}
           @object.foobar(1, 2).should == :return_value
         end
 
         it "matches to the last Double that was registered with an exact match" do
-          scenario_1 = scenario(1, 2) {:value_1}
-          scenario_2 = scenario(1, 2) {:value_2}
+          double_1 = double(1, 2) {:value_1}
+          double_2 = double(1, 2) {:value_2}
 
           @object.foobar(1, 2).should == :value_2
         end
 
         it "dispatches to Double with wildcard match" do
-          scenario = scenario(anything) {:return_value}
+          double = double(anything) {:return_value}
           @object.foobar(:dont_care).should == :return_value
         end
 
         it "matches to the last Double that was registered with a wildcard match" do
-          scenario_1 = scenario(anything) {:value_1}
-          scenario_2 = scenario(anything) {:value_2}
+          double_1 = double(anything) {:value_1}
+          double_2 = double(anything) {:value_2}
 
           @object.foobar(:dont_care).should == :value_2
         end
 
         it "matches to Double with exact match Double even when a Double with wildcard match was registered later" do
-          exact_scenario_registered_first = scenario(1, 2) {:exact_first}
-          wildcard_scenario_registered_last = scenario(anything, anything) {:wildcard_last}
+          exact_double_registered_first = double(1, 2) {:exact_first}
+          wildcard_double_registered_last = double(anything, anything) {:wildcard_last}
 
           @object.foobar(1, 2).should == :exact_first
         end
 
-        def scenario(*arguments, &return_value)
-          scenario = @space.scenario(@double_insertion)
-          scenario.with(*arguments).any_number_of_times.returns(&return_value)
-          scenario.should_not be_terminal
-          scenario
+        def double(*arguments, &return_value)
+          double = @space.double(@double_insertion)
+          double.with(*arguments).any_number_of_times.returns(&return_value)
+          double.should_not be_terminal
+          double
         end
       end
 
       describe "where there are Terminal Doubles with duplicate Exact Match ArgumentExpectations" do
         it "dispatches to Double that have an exact match" do
-          scenario1_with_exact_match = scenario(:exact_match) {:return_1}
+          double1_with_exact_match = double(:exact_match) {:return_1}
 
           @object.foobar(:exact_match).should == :return_1
         end
 
         it "dispatches to the first Double that have an exact match" do
-          scenario1_with_exact_match = scenario(:exact_match) {:return_1}
-          scenario2_with_exact_match = scenario(:exact_match) {:return_2}
+          double1_with_exact_match = double(:exact_match) {:return_1}
+          double2_with_exact_match = double(:exact_match) {:return_2}
 
           @object.foobar(:exact_match).should == :return_1
         end
 
         it "dispatches the second Double with an exact match
-          when the first scenario's Times Called expectation is satisfied" do
-          scenario1_with_exact_match = scenario(:exact_match) {:return_1}
-          scenario2_with_exact_match = scenario(:exact_match) {:return_2}
+          when the first double's Times Called expectation is satisfied" do
+          double1_with_exact_match = double(:exact_match) {:return_1}
+          double2_with_exact_match = double(:exact_match) {:return_2}
 
           @object.foobar(:exact_match)
           @object.foobar(:exact_match).should == :return_2
         end
 
-        it "raises TimesCalledError when all of the scenarios Times Called expectation is satisfied" do
-          scenario1_with_exact_match = scenario(:exact_match) {:return_1}
-          scenario2_with_exact_match = scenario(:exact_match) {:return_2}
+        it "raises TimesCalledError when all of the doubles Times Called expectation is satisfied" do
+          double1_with_exact_match = double(:exact_match) {:return_1}
+          double2_with_exact_match = double(:exact_match) {:return_2}
 
           @object.foobar(:exact_match)
           @object.foobar(:exact_match)
@@ -143,40 +143,40 @@ module RR
           end.should raise_error(Errors::TimesCalledError)
         end
 
-        def scenario(*arguments, &return_value)
-          scenario = @space.scenario(@double_insertion)
-          scenario.with(*arguments).once.returns(&return_value)
-          scenario.should be_terminal
-          scenario
+        def double(*arguments, &return_value)
+          double = @space.double(@double_insertion)
+          double.with(*arguments).once.returns(&return_value)
+          double.should be_terminal
+          double
         end
       end
 
-      describe "where there are scenarios with duplicate Wildcard Match ArgumentExpectations" do
+      describe "where there are doubles with duplicate Wildcard Match ArgumentExpectations" do
         it "dispatches to Double that have a wildcard match" do
-          scenario_1 = scenario {:return_1}
+          double_1 = double {:return_1}
 
           @object.foobar(:anything).should == :return_1
         end
 
         it "dispatches to the first Double that has a wildcard match" do
-          scenario_1 = scenario {:return_1}
-          scenario_2 = scenario {:return_2}
+          double_1 = double {:return_1}
+          double_2 = double {:return_2}
 
           @object.foobar(:anything).should == :return_1
         end
 
         it "dispatches the second Double with a wildcard match
-          when the first scenario's Times Called expectation is satisfied" do
-          scenario_1 = scenario {:return_1}
-          scenario_2 = scenario {:return_2}
+          when the first double's Times Called expectation is satisfied" do
+          double_1 = double {:return_1}
+          double_2 = double {:return_2}
 
           @object.foobar(:anything)
           @object.foobar(:anything).should == :return_2
         end
 
-        it "raises TimesCalledError when all of the scenarios Times Called expectation is satisfied" do
-          scenario_1 = scenario {:return_1}
-          scenario_2 = scenario {:return_2}
+        it "raises TimesCalledError when all of the doubles Times Called expectation is satisfied" do
+          double_1 = double {:return_1}
+          double_2 = double {:return_2}
 
           @object.foobar(:anything)
           @object.foobar(:anything)
@@ -185,11 +185,11 @@ module RR
           end.should raise_error(Errors::TimesCalledError)
         end
 
-        def scenario(&return_value)
-          scenario = @space.scenario(@double_insertion)
-          scenario.with_any_args.once.returns(&return_value)
-          scenario.should be_terminal
-          scenario
+        def double(&return_value)
+          double = @space.double(@double_insertion)
+          double.with_any_args.once.returns(&return_value)
+          double.should be_terminal
+          double
         end
       end
     end
@@ -200,8 +200,8 @@ module RR
       end
 
       it "executes the block" do
-        scenario = @space.scenario(@double_insertion)
-        scenario.with(1, 2) {:return_value}
+        double = @space.double(@double_insertion)
+        double.with(1, 2) {:return_value}
         @object.foobar!(1, 2).should == :return_value
       end
     end
@@ -212,8 +212,8 @@ module RR
       end
 
       it "executes the block" do
-        scenario = @space.scenario(@double_insertion)
-        scenario.with(1, 2) {:return_value}
+        double = @space.double(@double_insertion)
+        double.with(1, 2) {:return_value}
         @object.foobar?(1, 2).should == :return_value
       end
     end