rr 0.4.2 → 0.4.3

data/spec/rr/double/double_injection_register_scenario_spec.rb

@@ -1,24 +1,24 @@
 require "spec/spec_helper"
 
 module RR
-  describe DoubleInjection, "#register_scenario" do
+  describe DoubleInjection, "#register_double" do
     before do
       @space = Space.new
       @object = Object.new
       @method_name = :foobar
       @object.methods.should_not include(@method_name.to_s)
       @double_insertion = DoubleInjection.new(@space, @object, @method_name)
-      def @double_insertion.scenarios
-        @scenarios
+      def @double_insertion.doubles
+        @doubles
       end
     end
 
-    it "adds the scenario to the scenarios list" do
-      scenario = Double.new(@space, @double_insertion, @space.scenario_definition)
+    it "adds the double to the doubles list" do
+      double = Double.new(@space, @double_insertion, @space.double_definition)
 
-      @double_insertion.scenarios.should_not include(scenario)
-      @double_insertion.register_scenario scenario
-      @double_insertion.scenarios.should include(scenario)
+      @double_insertion.doubles.should_not include(double)
+      @double_insertion.register_double double
+      @double_insertion.doubles.should include(double)
     end
   end
 end

data/spec/rr/double/double_injection_verify_spec.rb

@@ -10,11 +10,11 @@ module RR
       @double_insertion = @space.double_insertion(@object, @method_name)
     end
 
-    it "verifies each scenario was met" do
-      scenario = Double.new(@space, @double_insertion, @space.scenario_definition)
-      @double_insertion.register_scenario scenario
+    it "verifies each double was met" do
+      double = Double.new(@space, @double_insertion, @space.double_definition)
+      @double_insertion.register_double double
 
-      scenario.with(1).once.returns {nil}
+      double.with(1).once.returns {nil}
       proc {@double_insertion.verify}.should raise_error(Errors::TimesCalledError)
       @object.foobar(1)
       proc {@double_insertion.verify}.should_not raise_error

data/spec/rr/double_creator_spec.rb

@@ -7,13 +7,13 @@ module RR
     end
 
     it "returns a DoubleMethodProxy when passed a subject" do
-      scenario = creator.__send__(method_name, subject).foobar
-      scenario.should be_instance_of(DoubleDefinition)
+      double = creator.__send__(method_name, subject).foobar
+      double.should be_instance_of(DoubleDefinition)
     end
 
     it "returns a DoubleMethodProxy when passed Kernel" do
-      scenario = creator.__send__(method_name, Kernel).foobar
-      scenario.should be_instance_of(DoubleDefinition)
+      double = creator.__send__(method_name, Kernel).foobar
+      double.should be_instance_of(DoubleDefinition)
     end
 
     it "raises error if passed a method name and a block" do
@@ -73,30 +73,30 @@ module RR
       end
 
       it "creates a mock Double for method when passed a second argument with rr_mock" do
-        creates_scenario_with_method_name(
+        creates_double_with_method_name(
         creator.mock(subject, :foobar)
         )
       end
 
       it "sets up the DoubleDefinition to be in returns block_callback_strategy" do
-        scenario = creator.mock(subject, :foobar)
-        scenario.block_callback_strategy.should == :returns
+        double = creator.mock(subject, :foobar)
+        double.block_callback_strategy.should == :returns
       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
@@ -114,25 +114,25 @@ module RR
       end
 
       it "creates a stub Double for method when passed a second argument" do
-        creates_scenario_with_method_name(creator.stub(subject, :foobar))
+        creates_double_with_method_name(creator.stub(subject, :foobar))
       end
 
       it "sets up the DoubleDefinition to be in returns block_callback_strategy" do
-        scenario = creator.stub(subject, :foobar)
-        scenario.block_callback_strategy.should == :returns
+        double = creator.stub(subject, :foobar)
+        double.block_callback_strategy.should == :returns
       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
@@ -171,26 +171,26 @@ module RR
       end
 
       it "creates a mock Double for method when passed a second argument" do
-        creates_scenario_with_method_name(creator.dont_allow(subject, :foobar))
+        creates_double_with_method_name(creator.dont_allow(subject, :foobar))
       end
 
       it "creates a mock Double for method when passed a second argument" do
-        creates_scenario_with_method_name(creator.dont_call(subject, :foobar))
+        creates_double_with_method_name(creator.dont_call(subject, :foobar))
       end
 
       it "creates a mock Double for method when passed a second argument" do
-        creates_scenario_with_method_name(creator.do_not_allow(subject, :foobar))
+        creates_double_with_method_name(creator.do_not_allow(subject, :foobar))
       end
 
       it "creates a mock Double for method when passed a second argument" do
-        creates_scenario_with_method_name(creator.dont_allow(subject, :foobar))
+        creates_double_with_method_name(creator.dont_allow(subject, :foobar))
       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)
@@ -200,10 +200,10 @@ module RR
       end
 
       def creates_dont_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)
@@ -233,32 +233,32 @@ module RR
       end
 
       it "sets up the RR proxy call chain" do
-        scenario = creator.stub.proxy(subject).foobar(1, 2) {:baz}
-        scenario.times_matcher.should == TimesCalledMatchers::AnyTimesMatcher.new
-        scenario.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
+        double = creator.stub.proxy(subject).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
 
       it "sets up the RR proxy call chain" do
-        scenario = creator.stub.proxy(subject).foobar(1, 2) {:baz}
-        scenario.times_matcher.should == TimesCalledMatchers::AnyTimesMatcher.new
-        scenario.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
+        double = creator.stub.proxy(subject).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
 
       it "creates a proxy Double for method when passed a second argument" do
-        scenario = creator.stub.proxy(subject, :foobar)
-        scenario.with(1, 2) {:baz}
-        scenario.times_matcher.should == TimesCalledMatchers::AnyTimesMatcher.new
-        scenario.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
+        double = creator.stub.proxy(subject, :foobar)
+        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
 
       it "creates a proxy Double for method when passed a second argument" do
-        scenario = creator.stub.proxy(subject, :foobar)
-        scenario.with(1, 2) {:baz}
-        scenario.times_matcher.should == TimesCalledMatchers::AnyTimesMatcher.new
-        scenario.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
+        double = creator.stub.proxy(subject, :foobar)
+        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
 
@@ -268,12 +268,12 @@ module RR
         end
 
         args = nil
-        scenario = creator.stub.proxy(subject, :foobar).with() do |*args|
+        double = creator.stub.proxy(subject, :foobar).with() do |*args|
           args = args
         end
         subject.foobar
         args.should == [:original_implementation_value]
-        scenario.block_callback_strategy.should == :after_call
+        double.block_callback_strategy.should == :after_call
       end
     end
 
@@ -286,18 +286,18 @@ module RR
 
       it "sets up the RR proxy call chain" do
         klass = Class.new
-        scenario = creator.stub.instance_of(klass).foobar(1, 2) {:baz}
-        scenario.times_matcher.should == TimesCalledMatchers::AnyTimesMatcher.new
-        scenario.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
+        double = creator.stub.instance_of(klass).foobar(1, 2) {:baz}
+        double.times_matcher.should == TimesCalledMatchers::AnyTimesMatcher.new
+        double.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
         klass.new.foobar(1, 2).should == :baz
       end
 
       it "creates a proxy Double for method when passed a second argument" do
         klass = Class.new
-        scenario = creator.stub.instance_of(klass, :foobar)
-        scenario.with(1, 2) {:baz}
-        scenario.times_matcher.should == TimesCalledMatchers::AnyTimesMatcher.new
-        scenario.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
+        double = creator.stub.instance_of(klass, :foobar)
+        double.with(1, 2) {:baz}
+        double.times_matcher.should == TimesCalledMatchers::AnyTimesMatcher.new
+        double.argument_expectation.class.should == RR::Expectations::ArgumentEqualityExpectation
         klass.new.foobar(1, 2).should == :baz
       end
     end
@@ -387,7 +387,7 @@ module RR
         proc {subject.foobar(1, 2)}.should raise_error(Errors::TimesCalledError)
       end
 
-      it "sets after_call on the scenario when passed a block" do
+      it "sets after_call on the double when passed a block" do
         real_value = Object.new
         (
         class << subject;
@@ -412,7 +412,7 @@ module RR
         creator.proxy
       end
 
-      it "sets up a scenario with passed in arguments" do
+      it "sets up a double with passed in arguments" do
         def subject.foobar(*args)
           ; :baz;
         end
@@ -432,7 +432,7 @@ module RR
         end
       end
 
-      it "sets after_call on the scenario when passed a block" do
+      it "sets after_call on the double when passed a block" do
         real_value = Object.new
         (
         class << subject;

data/spec/rr/double_definition_spec.rb

@@ -7,8 +7,8 @@ describe DoubleDefinition, :shared => true do
     @object = Object.new
     add_original_method
     @double_insertion = @space.double_insertion(@object, :foobar)
-    @scenario = @space.scenario(@double_insertion)
-    @definition = @scenario.definition
+    @double = @space.double(@double_insertion)
+    @definition = @double.definition
   end
 
   def add_original_method
@@ -454,14 +454,14 @@ end
 describe DoubleDefinition, "#ordered", :shared => true do
   it_should_behave_like "RR::DoubleDefinition"
 
-  it "adds itself to the ordered scenarios list" do
+  it "adds itself to the ordered doubles list" do
     @definition.ordered
-    @space.ordered_scenarios.should include(@scenario)
+    @space.ordered_doubles.should include(@double)
   end
 
   it "does not double_insertion add itself" do
     @definition.ordered
-    @space.ordered_scenarios.should == [@scenario]
+    @space.ordered_doubles.should == [@double]
   end
 
   it "sets ordered? to true" do
@@ -469,7 +469,7 @@ describe DoubleDefinition, "#ordered", :shared => true do
   end
 
   it "raises error when there is no Double" do
-    @definition.scenario = nil
+    @definition.double = nil
     proc do
       @definition.ordered
     end.should raise_error(
@@ -684,9 +684,9 @@ describe DoubleDefinition, "#implemented_by_original_method" do
       end
     end
     double_insertion = @space.double_insertion(@object, :does_not_exist)
-    scenario = @space.scenario(double_insertion)
-    scenario.with_any_args
-    scenario.implemented_by_original_method
+    double = @space.double(double_insertion)
+    double.with_any_args
+    double.implemented_by_original_method
 
     return_value = @object.does_not_exist(1, 2)
     return_value.should == "method_missing for does_not_exist([1, 2])"

data/spec/rr/double_method_proxy_spec.rb

@@ -15,7 +15,7 @@ module RR
     before(:each) do
       @space = Space.new
       @subject = Object.new
-      @creator = space.scenario_creator
+      @creator = space.double_creator
       creator.mock
     end
 
@@ -27,13 +27,13 @@ module RR
 
       it "clears out all methods from proxy" do
         proxy_subclass = Class.new(DoubleMethodProxy) do
-          def i_should_be_a_scenario
+          def i_should_be_a_double
           end
         end
-        proxy_subclass.instance_methods.should include('i_should_be_a_scenario')
+        proxy_subclass.instance_methods.should include('i_should_be_a_double')
 
         proxy = proxy_subclass.new(space, creator, subject)
-        proxy.i_should_be_a_scenario.should be_instance_of(DoubleDefinition)
+        proxy.i_should_be_a_double.should be_instance_of(DoubleDefinition)
       end
     end
 
@@ -57,13 +57,13 @@ module RR
 
       it "clears out all methods from proxy" do
         proxy_subclass = Class.new(DoubleMethodProxy) do
-          def i_should_be_a_scenario
+          def i_should_be_a_double
           end
         end
-        proxy_subclass.instance_methods.should include('i_should_be_a_scenario')
+        proxy_subclass.instance_methods.should include('i_should_be_a_double')
 
         proxy_subclass.new(space, creator, subject) do |m|
-          m.i_should_be_a_scenario.should be_instance_of(DoubleDefinition)
+          m.i_should_be_a_double.should be_instance_of(DoubleDefinition)
         end
       end
     end

data/spec/rr/double_spec.rb

@@ -2,7 +2,7 @@ require "spec/spec_helper"
 
 module RR
   describe Double do
-    attr_reader :space, :object, :double_insertion, :scenario
+    attr_reader :space, :object, :double_insertion, :double
     before do
       @space = Space.new
       @object = Object.new
@@ -10,38 +10,38 @@ module RR
         [b, a]
       end
       @double_insertion = space.double_insertion(object, :foobar)
-      @scenario = space.scenario(double_insertion)
+      @double = space.double(double_insertion)
     end
 
     describe "#with" do
       it "returns DoubleDefinition" do
-        scenario.with(1).should === scenario.definition
+        double.with(1).should === double.definition
       end
 
       it "sets an ArgumentEqualityExpectation" do
-        scenario.with(1)
-        scenario.should be_exact_match(1)
-        scenario.should_not be_exact_match(2)
+        double.with(1)
+        double.should be_exact_match(1)
+        double.should_not be_exact_match(2)
       end
 
       it "sets return value when block passed in" do
-        scenario.with(1) {:return_value}
+        double.with(1) {:return_value}
         object.foobar(1).should == :return_value
       end
     end
 
     describe "#with_any_args" do
       before do
-        scenario.with_any_args {:return_value}
+        double.with_any_args {:return_value}
       end
 
       it "returns DoubleDefinition" do
-        scenario.with_no_args.should === scenario.definition
+        double.with_no_args.should === double.definition
       end
 
       it "sets an AnyArgumentExpectation" do
-        scenario.should_not be_exact_match(1)
-        scenario.should be_wildcard_match(1)
+        double.should_not be_exact_match(1)
+        double.should be_wildcard_match(1)
       end
 
       it "sets return value when block passed in" do
@@ -51,15 +51,15 @@ module RR
 
     describe "#with_no_args" do
       before do
-        scenario.with_no_args {:return_value}
+        double.with_no_args {:return_value}
       end
 
       it "returns DoubleDefinition" do
-        scenario.with_no_args.should === scenario.definition
+        double.with_no_args.should === double.definition
       end
 
       it "sets an ArgumentEqualityExpectation with no arguments" do
-        scenario.argument_expectation.should == Expectations::ArgumentEqualityExpectation.new()
+        double.argument_expectation.should == Expectations::ArgumentEqualityExpectation.new()
       end
 
       it "sets return value when block passed in" do
@@ -69,82 +69,82 @@ module RR
 
     describe "#never" do
       it "returns DoubleDefinition" do
-        scenario.never.should === scenario.definition
+        double.never.should === double.definition
       end
 
       it "sets up a Times Called Expectation with 0" do
-        scenario.never
-        proc {scenario.call(double_insertion)}.should raise_error(Errors::TimesCalledError)
+        double.never
+        proc {double.call(double_insertion)}.should raise_error(Errors::TimesCalledError)
       end
 
       it "sets return value when block passed in" do
-        scenario.with_any_args.never
-        proc {scenario.call(double_insertion)}.should raise_error(Errors::TimesCalledError)
+        double.with_any_args.never
+        proc {double.call(double_insertion)}.should raise_error(Errors::TimesCalledError)
       end
     end
 
     describe "#once" do
       it "returns DoubleDefinition" do
-        scenario.once.should === scenario.definition
+        double.once.should === double.definition
       end
 
       it "sets up a Times Called Expectation with 1" do
-        scenario.once
-        scenario.call(double_insertion)
-        proc {scenario.call(double_insertion)}.should raise_error(Errors::TimesCalledError)
+        double.once
+        double.call(double_insertion)
+        proc {double.call(double_insertion)}.should raise_error(Errors::TimesCalledError)
       end
 
       it "sets return value when block passed in" do
-        scenario.with_any_args.once {:return_value}
+        double.with_any_args.once {:return_value}
         object.foobar.should == :return_value
       end
     end
 
     describe "#twice" do
       it "returns DoubleDefinition" do
-        scenario.twice.should === scenario.definition
+        double.twice.should === double.definition
       end
 
       it "sets up a Times Called Expectation with 2" do
-        scenario.twice
-        scenario.call(double_insertion)
-        scenario.call(double_insertion)
-        proc {scenario.call(double_insertion)}.should raise_error(Errors::TimesCalledError)
+        double.twice
+        double.call(double_insertion)
+        double.call(double_insertion)
+        proc {double.call(double_insertion)}.should raise_error(Errors::TimesCalledError)
       end
 
       it "sets return value when block passed in" do
-        scenario.with_any_args.twice {:return_value}
+        double.with_any_args.twice {:return_value}
         object.foobar.should == :return_value
       end
     end
 
     describe "#at_least" do
       it "returns DoubleDefinition" do
-        scenario.with_any_args.at_least(2).should === scenario.definition
+        double.with_any_args.at_least(2).should === double.definition
       end
 
       it "sets up a AtLeastMatcher with 2" do
-        scenario.at_least(2)
-        scenario.definition.times_matcher.should == TimesCalledMatchers::AtLeastMatcher.new(2)
+        double.at_least(2)
+        double.definition.times_matcher.should == TimesCalledMatchers::AtLeastMatcher.new(2)
       end
 
       it "sets return value when block passed in" do
-        scenario.with_any_args.at_least(2) {:return_value}
+        double.with_any_args.at_least(2) {:return_value}
         object.foobar.should == :return_value
       end
     end
 
     describe "#at_most" do
       it "returns DoubleDefinition" do
-        scenario.with_any_args.at_most(2).should === scenario.definition
+        double.with_any_args.at_most(2).should === double.definition
       end
 
       it "sets up a Times Called Expectation with 1" do
-        scenario.at_most(2)
-        scenario.call(double_insertion)
-        scenario.call(double_insertion)
+        double.at_most(2)
+        double.call(double_insertion)
+        double.call(double_insertion)
         proc do
-          scenario.call(double_insertion)
+          double.call(double_insertion)
         end.should raise_error(
         Errors::TimesCalledError,
         "foobar()\nCalled 3 times.\nExpected at most 2 times."
@@ -152,89 +152,89 @@ module RR
       end
 
       it "sets return value when block passed in" do
-        scenario.with_any_args.at_most(2) {:return_value}
+        double.with_any_args.at_most(2) {:return_value}
         object.foobar.should == :return_value
       end
     end
 
     describe "#times" do
       it "returns DoubleDefinition" do
-        scenario.times(3).should === scenario.definition
+        double.times(3).should === double.definition
       end
 
       it "sets up a Times Called Expectation with passed in times" do
-        scenario.times(3)
-        scenario.call(double_insertion)
-        scenario.call(double_insertion)
-        scenario.call(double_insertion)
-        proc {scenario.call(double_insertion)}.should raise_error(Errors::TimesCalledError)
+        double.times(3)
+        double.call(double_insertion)
+        double.call(double_insertion)
+        double.call(double_insertion)
+        proc {double.call(double_insertion)}.should raise_error(Errors::TimesCalledError)
       end
 
       it "sets return value when block passed in" do
-        scenario.with_any_args.times(3) {:return_value}
+        double.with_any_args.times(3) {:return_value}
         object.foobar.should == :return_value
       end
     end
 
     describe "#any_number_of_times" do
       it "returns DoubleDefinition" do
-        scenario.any_number_of_times.should === scenario.definition
+        double.any_number_of_times.should === double.definition
       end
 
       it "sets up a Times Called Expectation with AnyTimes matcher" do
-        scenario.any_number_of_times
-        scenario.times_matcher.should == TimesCalledMatchers::AnyTimesMatcher.new
+        double.any_number_of_times
+        double.times_matcher.should == TimesCalledMatchers::AnyTimesMatcher.new
       end
 
       it "sets return value when block passed in" do
-        scenario.with_any_args.any_number_of_times {:return_value}
+        double.with_any_args.any_number_of_times {:return_value}
         object.foobar.should == :return_value
       end
     end
 
     describe "#ordered" do
-      it "adds itself to the ordered scenarios list" do
-        scenario.ordered
-        space.ordered_scenarios.should include(scenario)
+      it "adds itself to the ordered doubles list" do
+        double.ordered
+        space.ordered_doubles.should include(double)
       end
 
       it "does not double_insertion add itself" do
-        scenario.ordered
-        scenario.ordered
-        space.ordered_scenarios.should == [scenario ]
+        double.ordered
+        double.ordered
+        space.ordered_doubles.should == [double ]
       end
 
       it "sets ordered? to true" do
-        scenario.ordered
-        scenario.should be_ordered
+        double.ordered
+        double.should be_ordered
       end
 
       it "sets return value when block passed in" do
-        scenario.with_any_args.once.ordered {:return_value}
+        double.with_any_args.once.ordered {:return_value}
         object.foobar.should == :return_value
       end
     end
 
     describe "#ordered?" do
       it "defaults to false" do
-        scenario.should_not be_ordered
+        double.should_not be_ordered
       end
     end
     
     describe "#yields" do
       it "returns DoubleDefinition" do
-        scenario.yields(:baz).should === scenario.definition
+        double.yields(:baz).should === double.definition
       end
 
       it "yields the passed in argument to the call block when there is no returns value set" do
-        scenario.with_any_args.yields(:baz)
+        double.with_any_args.yields(:baz)
         passed_in_block_arg = nil
         object.foobar {|arg| passed_in_block_arg = arg}.should == nil
         passed_in_block_arg.should == :baz
       end
 
       it "yields the passed in argument to the call block when there is a no returns value set" do
-        scenario.with_any_args.yields(:baz).returns(:return_value)
+        double.with_any_args.yields(:baz).returns(:return_value)
 
         passed_in_block_arg = nil
         object.foobar {|arg| passed_in_block_arg = arg}.should == :return_value
@@ -242,41 +242,41 @@ module RR
       end
 
       it "sets return value when block passed in" do
-        scenario.with_any_args.yields {:return_value}
+        double.with_any_args.yields {:return_value}
         object.foobar {}.should == :return_value
       end
     end
 
     describe "#after_call" do
       it "returns DoubleDefinition" do
-        scenario.after_call {}.should === scenario.definition
+        double.after_call {}.should === double.definition
       end
 
       it "sends return value of Double implementation to after_call" do
         return_value = {}
-        scenario.returns(return_value).after_call do |value|
+        double.returns(return_value).after_call do |value|
           value[:foo] = :bar
           value
         end
 
-        actual_value = scenario.call(double_insertion)
+        actual_value = double.call(double_insertion)
         actual_value.should === return_value
         actual_value.should == {:foo => :bar}
       end
 
       it "receives the return value in the after_call callback" do
         return_value = :returns_value
-        scenario.returns(return_value).after_call do |value|
+        double.returns(return_value).after_call do |value|
           :after_call_value
         end
 
-        actual_value = scenario.call(double_insertion)
+        actual_value = double.call(double_insertion)
         actual_value.should == :after_call_value
       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|
+        double.with_any_args.returns(return_value).after_call do |value|
           mock(value).inner_method(1) {:baz}
           value
         end
@@ -286,66 +286,66 @@ module RR
 
       it "raises an error when not passed a block" do
         proc do
-          scenario.after_call
+          double.after_call
         end.should raise_error(ArgumentError, "after_call expects a block")
       end
     end
 
     describe "#returns" do
       it "returns DoubleDefinition" do
-        scenario.returns {:baz}.should === scenario.definition
-        scenario.returns(:baz).should === scenario.definition
+        double.returns {:baz}.should === double.definition
+        double.returns(:baz).should === double.definition
       end
 
       it "sets the value of the method when passed a block" do
-        scenario.returns {:baz}
-        scenario.call(double_insertion).should == :baz
+        double.returns {:baz}
+        double.call(double_insertion).should == :baz
       end
 
       it "sets the value of the method when passed an argument" do
-        scenario.returns(:baz)
-        scenario.call(double_insertion).should == :baz
+        double.returns(:baz)
+        double.call(double_insertion).should == :baz
       end
 
       it "returns false when passed false" do
-        scenario.returns(false)
-        scenario.call(double_insertion).should == false
+        double.returns(false)
+        double.call(double_insertion).should == false
       end
 
       it "raises an error when both argument and block is passed in" do
         proc do
-          scenario.returns(:baz) {:another}
+          double.returns(:baz) {:another}
         end.should raise_error(ArgumentError, "returns cannot accept both an argument and a block")
       end
     end
 
     describe "#implemented_by" do
       it "returns the DoubleDefinition" do
-        scenario.implemented_by(proc{:baz}).should === scenario.definition
+        double.implemented_by(proc{:baz}).should === double.definition
       end
 
       it "sets the implementation to the passed in proc" do
-        scenario.implemented_by(proc{:baz})
-        scenario.call(double_insertion).should == :baz
+        double.implemented_by(proc{:baz})
+        double.call(double_insertion).should == :baz
       end
 
       it "sets the implementation to the passed in method" do
         def object.foobar(a, b)
           [b, a]
         end
-        scenario.implemented_by(object.method(:foobar))
-        scenario.call(double_insertion, 1, 2).should == [2, 1]
+        double.implemented_by(object.method(:foobar))
+        double.call(double_insertion, 1, 2).should == [2, 1]
       end
     end
 
     describe "#implemented_by_original_method" do
       it "returns the DoubleDefinition object" do
-        scenario.implemented_by_original_method.should === scenario.definition
+        double.implemented_by_original_method.should === double.definition
       end
 
       it "sets the implementation to the original method" do
-        scenario.implemented_by_original_method
-        scenario.call(double_insertion, 1, 2).should == [2, 1]
+        double.implemented_by_original_method
+        double.call(double_insertion, 1, 2).should == [2, 1]
       end
 
       it "calls methods when respond_to? is true and methods does not contain original method" do
@@ -366,9 +366,9 @@ module RR
         end
 
         double_insertion = space.double_insertion(object, :foobar)
-        scenario = space.scenario(double_insertion)
-        scenario.with_any_args
-        scenario.implemented_by_original_method
+        double = space.double(double_insertion)
+        double.with_any_args
+        double.implemented_by_original_method
 
         object.foobar(1, 2).should == [2, 1]
       end
@@ -380,9 +380,9 @@ module RR
           end
         end
         double_insertion = space.double_insertion(object, :does_not_exist)
-        scenario = space.scenario(double_insertion)
-        scenario.with_any_args
-        scenario.implemented_by_original_method
+        double = space.double(double_insertion)
+        double.with_any_args
+        double.implemented_by_original_method
 
         return_value = object.does_not_exist(1, 2)
         return_value.should == "method_missing for does_not_exist([1, 2])"
@@ -391,40 +391,40 @@ module RR
 
     describe "#call implemented by a proc" do
       it "calls the return proc when implemented by a proc" do
-        scenario.returns {|arg| "returning #{arg}"}
-        scenario.call(double_insertion, :foobar).should == "returning foobar"
+        double.returns {|arg| "returning #{arg}"}
+        double.call(double_insertion, :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|
+        double.returns {|arg| "returning #{arg}"}.after_call do |value|
           "#{value} after call"
         end
-        scenario.call(double_insertion, :foobar).should == "returning foobar after call"
+        double.call(double_insertion, :foobar).should == "returning foobar after call"
       end
 
       it "returns nil when to returns is not set" do
-        scenario.call(double_insertion).should be_nil
+        double.call(double_insertion).should be_nil
       end
 
       it "works when times_called is not set" do
-        scenario.returns {:value}
-        scenario.call(double_insertion)
+        double.returns {:value}
+        double.call(double_insertion)
       end
 
       it "verifes the times_called does not exceed the TimesCalledExpectation" do
-        scenario.times(2).returns {:value}
+        double.times(2).returns {:value}
 
-        scenario.call(double_insertion, :foobar)
-        scenario.call(double_insertion, :foobar)
-        proc {scenario.call(double_insertion, :foobar)}.should raise_error(Errors::TimesCalledError)
+        double.call(double_insertion, :foobar)
+        double.call(double_insertion, :foobar)
+        proc {double.call(double_insertion, :foobar)}.should raise_error(Errors::TimesCalledError)
       end
 
       it "raises DoubleOrderError when ordered and called out of order" do
-        scenario1 = scenario
-        scenario2 = space.scenario(double_insertion)
+        double1 = double
+        double2 = space.double(double_insertion)
 
-        scenario1.with(1).returns {:return_1}.ordered.once
-        scenario2.with(2).returns {:return_2}.ordered.once
+        double1.with(1).returns {:return_1}.ordered.once
+        double2.with(2).returns {:return_2}.ordered.once
 
         proc do
           object.foobar(2)
@@ -436,59 +436,59 @@ module RR
         )
       end
 
-      it "dispatches to Space#verify_ordered_scenario when ordered" do
-        verify_ordered_scenario_called = false
-        passed_in_scenario = nil
-        space.method(:verify_ordered_scenario).arity.should == 1
+      it "dispatches to Space#verify_ordered_double when ordered" do
+        verify_ordered_double_called = false
+        passed_in_double = nil
+        space.method(:verify_ordered_double).arity.should == 1
         (
         class << space;
           self;
         end).class_eval do
-          define_method :verify_ordered_scenario do |scenario|
-            passed_in_scenario = scenario
-            verify_ordered_scenario_called = true
+          define_method :verify_ordered_double do |double|
+            passed_in_double = double
+            verify_ordered_double_called = true
           end
         end
 
-        scenario.returns {:value}.ordered
-        scenario.call(double_insertion, :foobar)
-        verify_ordered_scenario_called.should be_true
-        passed_in_scenario.should === scenario
+        double.returns {:value}.ordered
+        double.call(double_insertion, :foobar)
+        verify_ordered_double_called.should be_true
+        passed_in_double.should === double
       end
 
-      it "does not dispatche to Space#verify_ordered_scenario when not ordered" do
-        verify_ordered_scenario_called = false
-        space.method(:verify_ordered_scenario).arity.should == 1
+      it "does not dispatche to Space#verify_ordered_double when not ordered" do
+        verify_ordered_double_called = false
+        space.method(:verify_ordered_double).arity.should == 1
         (
         class << space;
           self;
         end).class_eval do
-          define_method :verify_ordered_scenario do |scenario|
-            verify_ordered_scenario_called = true
+          define_method :verify_ordered_double do |double|
+            verify_ordered_double_called = true
           end
         end
 
-        scenario.returns {:value}
-        scenario.call(double_insertion, :foobar)
-        verify_ordered_scenario_called.should be_false
+        double.returns {:value}
+        double.call(double_insertion, :foobar)
+        verify_ordered_double_called.should be_false
       end
 
       it "does not add block argument if no block passed in" do
-        scenario.with(1, 2).returns {|*args| args}
+        double.with(1, 2).returns {|*args| args}
 
         args = object.foobar(1, 2)
         args.should == [1, 2]
       end
 
       it "makes the block the last argument" do
-        scenario.with(1, 2).returns {|a, b, blk| blk}
+        double.with(1, 2).returns {|a, b, blk| blk}
 
         block = object.foobar(1, 2) {|a, b| [b, a]}
         block.call(3, 4).should == [4, 3]
       end
 
       it "raises ArgumentError when yields was called and no block passed in" do
-        scenario.with(1, 2).yields(55)
+        double.with(1, 2).yields(55)
 
         proc do
           object.foobar(1, 2)
@@ -502,7 +502,7 @@ module RR
           yield(a, b)
         end
 
-        scenario.with(1, 2).implemented_by(object.method(:foobar))
+        double.with(1, 2).implemented_by(object.method(:foobar))
 
         object.foobar(1, 2) {|a, b| [b, a]}.should == [2, 1]
       end
@@ -510,144 +510,144 @@ module RR
     
     describe "#exact_match?" do
       it "returns false when no expectation set" do
-        scenario.should_not be_exact_match()
-        scenario.should_not be_exact_match(nil)
-        scenario.should_not be_exact_match(Object.new)
-        scenario.should_not be_exact_match(1, 2, 3)
+        double.should_not be_exact_match()
+        double.should_not be_exact_match(nil)
+        double.should_not be_exact_match(Object.new)
+        double.should_not be_exact_match(1, 2, 3)
       end
 
       it "returns false when arguments are not an exact match" do
-        scenario.with(1, 2, 3)
-        scenario.should_not be_exact_match(1, 2)
-        scenario.should_not be_exact_match(1)
-        scenario.should_not be_exact_match()
-        scenario.should_not be_exact_match("does not match")
+        double.with(1, 2, 3)
+        double.should_not be_exact_match(1, 2)
+        double.should_not be_exact_match(1)
+        double.should_not be_exact_match()
+        double.should_not be_exact_match("does not match")
       end
 
       it "returns true when arguments are an exact match" do
-        scenario.with(1, 2, 3)
-        scenario.should be_exact_match(1, 2, 3)
+        double.with(1, 2, 3)
+        double.should be_exact_match(1, 2, 3)
       end
     end
 
     describe "#wildcard_match?" do
       it "returns false when no expectation set" do
-        scenario.should_not be_wildcard_match()
-        scenario.should_not be_wildcard_match(nil)
-        scenario.should_not be_wildcard_match(Object.new)
-        scenario.should_not be_wildcard_match(1, 2, 3)
+        double.should_not be_wildcard_match()
+        double.should_not be_wildcard_match(nil)
+        double.should_not be_wildcard_match(Object.new)
+        double.should_not be_wildcard_match(1, 2, 3)
       end
 
       it "returns true when arguments are an exact match" do
-        scenario.with(1, 2, 3)
-        scenario.should be_wildcard_match(1, 2, 3)
-        scenario.should_not be_wildcard_match(1, 2)
-        scenario.should_not be_wildcard_match(1)
-        scenario.should_not be_wildcard_match()
-        scenario.should_not be_wildcard_match("does not match")
+        double.with(1, 2, 3)
+        double.should be_wildcard_match(1, 2, 3)
+        double.should_not be_wildcard_match(1, 2)
+        double.should_not be_wildcard_match(1)
+        double.should_not be_wildcard_match()
+        double.should_not be_wildcard_match("does not match")
       end
 
       it "returns true when with_any_args" do
-        scenario.with_any_args
+        double.with_any_args
 
-        scenario.should be_wildcard_match(1, 2, 3)
-        scenario.should be_wildcard_match(1, 2)
-        scenario.should be_wildcard_match(1)
-        scenario.should be_wildcard_match()
-        scenario.should be_wildcard_match("does not match")
+        double.should be_wildcard_match(1, 2, 3)
+        double.should be_wildcard_match(1, 2)
+        double.should be_wildcard_match(1)
+        double.should be_wildcard_match()
+        double.should be_wildcard_match("does not match")
       end
     end
 
     describe "#attempt?" do
       it "returns true when TimesCalledExpectation#attempt? is true" do
-        scenario.with(1, 2, 3).twice
-        scenario.call(double_insertion, 1, 2, 3)
-        scenario.times_called_expectation.should be_attempt
-        scenario.should be_attempt
+        double.with(1, 2, 3).twice
+        double.call(double_insertion, 1, 2, 3)
+        double.times_called_expectation.should be_attempt
+        double.should be_attempt
       end
 
       it "returns false when TimesCalledExpectation#attempt? is true" do
-        scenario.with(1, 2, 3).twice
-        scenario.call(double_insertion, 1, 2, 3)
-        scenario.call(double_insertion, 1, 2, 3)
-        scenario.times_called_expectation.should_not be_attempt
-        scenario.should_not be_attempt
+        double.with(1, 2, 3).twice
+        double.call(double_insertion, 1, 2, 3)
+        double.call(double_insertion, 1, 2, 3)
+        double.times_called_expectation.should_not be_attempt
+        double.should_not be_attempt
       end
 
       it "returns true when there is no Times Called expectation" do
-        scenario.with(1, 2, 3)
-        scenario.definition.times_matcher.should be_nil
-        scenario.should be_attempt
+        double.with(1, 2, 3)
+        double.definition.times_matcher.should be_nil
+        double.should be_attempt
       end
     end
 
     describe "#verify" do
       it "verifies that times called expectation was met" do
-        scenario.twice.returns {:return_value}
+        double.twice.returns {:return_value}
 
-        proc {scenario.verify}.should raise_error(Errors::TimesCalledError)
-        scenario.call(double_insertion)
-        proc {scenario.verify}.should raise_error(Errors::TimesCalledError)
-        scenario.call(double_insertion)
+        proc {double.verify}.should raise_error(Errors::TimesCalledError)
+        double.call(double_insertion)
+        proc {double.verify}.should raise_error(Errors::TimesCalledError)
+        double.call(double_insertion)
 
-        proc {scenario.verify}.should_not raise_error
+        proc {double.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(double_insertion)
-        proc {scenario.verify}.should_not raise_error
-        scenario.call(double_insertion)
-        proc {scenario.verify}.should_not raise_error
+        proc {double.verify}.should_not raise_error
+        double.call(double_insertion)
+        proc {double.verify}.should_not raise_error
+        double.call(double_insertion)
+        proc {double.verify}.should_not raise_error
       end
     end
 
     describe "#terminal?" do
       it "returns true when times_called_expectation's terminal? is true" do
-        scenario.once
-        scenario.times_called_expectation.should be_terminal
-        scenario.should be_terminal
+        double.once
+        double.times_called_expectation.should be_terminal
+        double.should be_terminal
       end
 
       it "returns false when times_called_expectation's terminal? is false" do
-        scenario.any_number_of_times
-        scenario.times_called_expectation.should_not be_terminal
-        scenario.should_not be_terminal
+        double.any_number_of_times
+        double.times_called_expectation.should_not be_terminal
+        double.should_not be_terminal
       end
 
       it "returns false when there is no times_matcher" do
-        scenario.definition.times_matcher.should be_nil
-        scenario.should_not be_terminal
+        double.definition.times_matcher.should be_nil
+        double.should_not be_terminal
       end
     end
 
     describe "#method_name" do
       it "returns the DoubleInjection's method_name" do
         double_insertion.method_name.should == :foobar
-        scenario.method_name.should == :foobar
+        double.method_name.should == :foobar
       end
     end
 
     describe "#expected_arguments" do
       it "returns argument expectation's expected_arguments when there is a argument expectation" do
-        scenario.with(1, 2)
-        scenario.expected_arguments.should == [1, 2]
+        double.with(1, 2)
+        double.expected_arguments.should == [1, 2]
       end
 
       it "returns an empty array when there is no argument expectation" do
-        scenario.argument_expectation.should be_nil
-        scenario.expected_arguments.should == []
+        double.argument_expectation.should be_nil
+        double.expected_arguments.should == []
       end
     end
 
     describe "#formatted_name" do
       it "renders the formatted name of the Double with no arguments" do
-        scenario.formatted_name.should == "foobar()"
+        double.formatted_name.should == "foobar()"
       end
 
       it "renders the formatted name of the Double with arguments" do
-        scenario.with(1, 2)
-        scenario.formatted_name.should == "foobar(1, 2)"
+        double.with(1, 2)
+        double.formatted_name.should == "foobar(1, 2)"
       end
     end
   end