rr 0.4.10 → 0.6.0

data/spec/rr/expectations/times_called_expectation/times_called_expectation_range_spec.rb

@@ -1,81 +1,82 @@
-require "spec/spec_helper"
+require File.expand_path("#{File.dirname(__FILE__)}/../../../spec_helper")
 
 module RR
   module Expectations
-    describe TimesCalledExpectation, " with RangeMatcher" do
-      it_should_behave_like "RR::Expectations::TimesCalledExpectation"
-      attr_reader :matcher
+    describe TimesCalledExpectation do
+      context "when using a RangeMatcher" do
+        it_should_behave_like "RR::Expectations::TimesCalledExpectation"
+        attr_reader :matcher, :expectation
 
-      before do
-        @matcher = TimesCalledMatchers::RangeMatcher.new(1..2)
-        @expectation = TimesCalledExpectation.new(double, matcher)
-      end
-
-      describe "#verify" do
-        it "returns true when times called falls within a range" do
-          expectation.verify.should == false
-          expectation.attempt
-          expectation.verify.should == true
-          expectation.attempt
-          expectation.verify.should == true
+        before do
+          @matcher = TimesCalledMatchers::RangeMatcher.new(1..2)
+          @expectation = TimesCalledExpectation.new(double, matcher)
         end
-      end
 
-      describe "#verify! when passed a Range (1..2)" do
-        it "passes after attempt! called 1 time" do
-          expectation.attempt
-          expectation.verify!
+        describe "#verify" do
+          it "returns true when times called falls within a range" do
+            expectation.verify.should == false
+            expectation.attempt
+            expectation.verify.should == true
+            expectation.attempt
+            expectation.verify.should == true
+          end
         end
 
-        it "passes after attempt! called 2 times" do
-          expectation.attempt
-          expectation.attempt
-          expectation.verify!
-        end
+        describe "#verify! when passed a Range (1..2)" do
+          it "passes after attempt! called 1 time" do
+            expectation.attempt
+            expectation.verify!
+          end
 
-        it "can't be called when attempt! is called 3 times" do
-          expectation.attempt
-          expectation.attempt
-          lambda do
+          it "passes after attempt! called 2 times" do
             expectation.attempt
-          end.should raise_error(Errors::TimesCalledError, "foobar()\nCalled 3 times.\nExpected 1..2 times.")
-        end
-      end
+            expectation.attempt
+            expectation.verify!
+          end
 
-      describe "#attempt? with RangeMatcher" do
-        it "returns true when attempted less than low end of range" do
-          expectation.should be_attempt
+          it "can't be called when attempt! is called 3 times" do
+            expectation.attempt
+            expectation.attempt
+            lambda do
+              expectation.attempt
+            end.should raise_error(Errors::TimesCalledError, "foobar()\nCalled 3 times.\nExpected 1..2 times.")
+          end
         end
 
-        it "returns false when attempted in range" do
-          expectation.attempt
-          expectation.should be_attempt
-          expectation.attempt
-          expectation.should be_attempt
-        end
+        describe "#attempt? with RangeMatcher" do
+          it "returns true when attempted less than low end of range" do
+            expectation.should be_attempt
+          end
+
+          it "returns false when attempted in range" do
+            expectation.attempt
+            expectation.should be_attempt
+            expectation.attempt
+            expectation.should be_attempt
+          end
 
-        it "raises error before attempted more than expected times" do
-          2.times {expectation.attempt}
-          lambda {expectation.attempt}.should raise_error(
-          Errors::TimesCalledError
-          )
+          it "raises error before attempted more than expected times" do
+            2.times {expectation.attempt}
+            lambda {expectation.attempt}.should raise_error(
+            Errors::TimesCalledError
+            )
+          end
         end
-      end
 
-      describe "#attempt! for a range expectation" do
-        it "raises error when attempt! called more than range permits" do
-          expectation.attempt
-          expectation.attempt
-          raises_expectation_error {expectation.attempt}
+        describe "#attempt! for a range expectation" do
+          it "raises error when attempt! called more than range permits" do
+            expectation.attempt
+            expectation.attempt
+            raises_expectation_error {expectation.attempt}
+          end
         end
-      end
 
-      describe "#terminal? with RangeMatcher" do
-        it "returns true" do
-          expectation.should be_terminal
+        describe "#terminal? with RangeMatcher" do
+          it "returns true" do
+            expectation.should be_terminal
+          end
         end
       end
     end
-
   end
 end

data/spec/rr/expectations/times_called_expectation/times_called_expectation_spec.rb

@@ -1,36 +1,37 @@
-require "spec/spec_helper"
+require File.expand_path("#{File.dirname(__FILE__)}/../../../spec_helper")
 
 module RR
   module Expectations
-    describe TimesCalledExpectation, " with failure" do
-      it_should_behave_like "RR::Expectations::TimesCalledExpectation"
-      attr_reader :times, :matcher
+    describe TimesCalledExpectation do
+      context "with a failure" do
+        it_should_behave_like "RR::Expectations::TimesCalledExpectation"
+        attr_reader :times, :matcher, :expectation
 
-      before do
-        @times = 0
-        @matcher = TimesCalledMatchers::IntegerMatcher.new(times)
-        @expectation = TimesCalledExpectation.new(double, matcher)
-      end
+        before do
+          @times = 0
+          @matcher = TimesCalledMatchers::IntegerMatcher.new(times)
+          @expectation = TimesCalledExpectation.new(double, matcher)
+        end
 
-      describe "#attempt!" do
-        it "raises error that includes the double" do
-          lambda {expectation.attempt}.should raise_error(
-            Errors::TimesCalledError,
-            "#{double.formatted_name}\n#{matcher.error_message(1)}"
-          )
+        describe "#attempt!" do
+          it "raises error that includes the double" do
+            lambda {expectation.attempt}.should raise_error(
+              Errors::TimesCalledError,
+              "#{double.formatted_name}\n#{matcher.error_message(1)}"
+            )
+          end
         end
-      end
 
-      describe "#verify!" do
-        it "raises error with passed in message prepended" do
-          expectation.instance_variable_set(:@times_called, 1)
-          lambda {expectation.verify!}.should raise_error(
-            Errors::TimesCalledError,
-            "#{double.formatted_name}\n#{matcher.error_message(1)}"
-          )
+        describe "#verify!" do
+          it "raises error with passed in message prepended" do
+            expectation.instance_variable_set(:@times_called, 1)
+            lambda {expectation.verify!}.should raise_error(
+              Errors::TimesCalledError,
+              "#{double.formatted_name}\n#{matcher.error_message(1)}"
+            )
+          end
         end
       end
     end
-
   end
 end

data/spec/rr/rspec/rspec_adapter_spec.rb

@@ -1,22 +1,23 @@
-require "spec/spec_helper"
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
 
 module RR
   module Adapters
     describe Rspec do
+      attr_reader :fixture, :subject, :method_name
       describe "#setup_mocks_for_rspec" do
         before do
           @fixture = Object.new
-          @fixture.extend Rspec
+          fixture.extend Rspec
 
           @subject = Object.new
           @method_name = :foobar
         end
 
         it "resets the double_injections" do
-          RR.double_injection(@subject, @method_name)
+          RR.double_injection(subject, method_name)
           RR.double_injections.should_not be_empty
 
-          @fixture.setup_mocks_for_rspec
+          fixture.setup_mocks_for_rspec
           RR.double_injections.should be_empty
         end
       end
@@ -24,20 +25,20 @@ module RR
       describe "#verify_mocks_for_rspec" do
         before do
           @fixture = Object.new
-          @fixture.extend Rspec
+          fixture.extend Rspec
 
           @subject = Object.new
           @method_name = :foobar
         end
 
         it "verifies the double_injections" do
-          double_injection = RR.double_injection(@subject, @method_name)
-          double = RR::Double.new(double_injection)
+          double_injection = RR.double_injection(subject, method_name)
+          double = new_double(double_injection)
 
           double.once
 
           lambda do
-            @fixture.verify_mocks_for_rspec
+            fixture.verify_mocks_for_rspec
           end.should raise_error(::RR::Errors::TimesCalledError)
           RR.double_injections.should be_empty
         end
@@ -46,17 +47,17 @@ module RR
       describe "#teardown_mocks_for_rspec" do
         before do
           @fixture = Object.new
-          @fixture.extend Rspec
+          fixture.extend Rspec
 
           @subject = Object.new
           @method_name = :foobar
         end
 
         it "resets the double_injections" do
-          RR.double_injection(@subject, @method_name)
+          RR.double_injection(subject, method_name)
           RR.double_injections.should_not be_empty
 
-          @fixture.teardown_mocks_for_rspec
+          fixture.teardown_mocks_for_rspec
           RR.double_injections.should be_empty
         end
       end

data/spec/rr/rspec/rspec_backtrace_tweaking_spec.rb

@@ -1,4 +1,4 @@
-require "spec/spec_helper"
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
 
 module RR
   module Adapters
@@ -20,30 +20,32 @@ module RR
       end
 
       describe " backtrace tweaking" do
-        attr_reader :original_rspec_options, :output
+        attr_reader :original_rspec_options, :error, :output
         before do
-          @original_rspec_options = $rspec_options
+          @original_rspec_options = Spec::Runner.options
+          @error = StringIO.new("")
           @output = StringIO.new("")
-          $rspec_options = ::Spec::Runner::Options.new(output, StringIO.new)
+          Spec::Runner.use(::Spec::Runner::Options.new(error, output))
         end
 
         after do
-          $rspec_options = original_rspec_options
+          Spec::Runner.use(original_rspec_options)
         end
 
         it "hides rr library from the backtrace by default" do
           subject = @subject
-          Class.new(::Spec::Example::ExampleGroup) do
+          example_group = Class.new(::Spec::Example::ExampleGroup) do
             describe "Example"
 
             it("hides RR framework in backtrace") do
               mock(subject).foobar()
-              RR::Space::instance.verify_double(subject, :foobar)
+              RR.verify_double(subject, :foobar)
             end
           end
 
-          $rspec_options.run_examples
+          Spec::Runner.options.run_examples
 
+          output.string.should_not be_empty
           output.string.should_not include("lib/rr")
         end
       end

data/spec/rr/rspec/rspec_usage_spec.rb

@@ -1,4 +1,4 @@
-require "spec/spec_helper"
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
 
 describe RR do
   describe "#mock" do

data/spec/rr/space/hash_with_object_id_key_spec.rb

@@ -1,4 +1,4 @@
-require "spec/spec_helper"
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
 
 module RR
   describe HashWithObjectIdKey do

data/spec/rr/space/space_spec.rb

@@ -1,371 +1,510 @@
-require "spec/spec_helper"
+require File.expand_path("#{File.dirname(__FILE__)}/../../spec_helper")
 
 module RR
   describe Space do
     it_should_behave_like "Swapped Space"
+    attr_reader :space, :subject, :method_name, :double_injection
+
+    before do
+      @subject = Object.new
+    end
 
     describe ".method_missing" do
       it "proxies to a singleton instance of Space" do
         create_double_args = nil
-        (class << @space; self; end).class_eval do
+        (class << space; self; end).class_eval do
           define_method :double_injection do |*args|
             create_double_args = args
           end
         end
 
-        Space.double_injection(:foo, :bar)
+        space.double_injection(:foo, :bar)
         create_double_args.should == [:foo, :bar]
       end
     end
 
     describe "#double_injection" do
-      before do
-        @space = Space.new
-      end
+      context "when existing subject == but not === with the same method name" do
+        it "creates a new DoubleInjection" do
+          subject_1 = []
+          subject_2 = []
+          (subject_1 === subject_2).should be_true
+          subject_1.__id__.should_not == subject_2.__id__
 
-      it "creates a new double_injection when existing object == but not === with the same method name" do
-        object1 = []
-        object2 = []
-        (object1 === object2).should be_true
-        object1.__id__.should_not == object2.__id__
+          double_1 = space.double_injection(subject_1, :foobar)
+          double_2 = space.double_injection(subject_2, :foobar)
 
-        double1 = @space.double_injection(object1, :foobar)
-        double2 = @space.double_injection(object2, :foobar)
-
-        double1.should_not == double2
+          double_1.should_not == double_2
+        end
       end
 
       context "when double_injection does not exist" do
         before do
-          @object = Object.new
-          def @object.foobar(*args)
+          def subject.foobar(*args)
             :original_foobar
           end
           @method_name = :foobar
         end
 
-        it "returns double_injection and adds double_injection to double_injection list when method_name is a symbol" do
-          double_injection = @space.double_injection(@object, @method_name)
-          @space.double_injection(@object, @method_name).should === double_injection
-          double_injection.object.should === @object
-          double_injection.method_name.should === @method_name
+        context "when method_name is a symbol" do
+          it "returns double_injection and adds double_injection to double_injection list" do
+            @double_injection = space.double_injection(subject, method_name)
+            space.double_injection(subject, method_name).should === double_injection
+            double_injection.subject.should === subject
+            double_injection.method_name.should === method_name
+          end
         end
 
-        it "returns double_injection and adds double_injection to double_injection list when method_name is a string" do
-          double_injection = @space.double_injection(@object, 'foobar')
-          @space.double_injection(@object, @method_name).should === double_injection
-          double_injection.object.should === @object
-          double_injection.method_name.should === @method_name
+        context "when method_name is a string" do
+          it "returns double_injection and adds double_injection to double_injection list" do
+            @double_injection = space.double_injection(subject, 'foobar')
+            space.double_injection(subject, method_name).should === double_injection
+            double_injection.subject.should === subject
+            double_injection.method_name.should === method_name
+          end
         end
 
         it "overrides the method when passing a block" do
-          double_injection = @space.double_injection(@object, @method_name)
-          @object.methods.should include("__rr__#{@method_name}")
+          @double_injection = space.double_injection(subject, method_name)
+          subject.methods.should include("__rr__#{method_name}")
         end
       end
 
       context "when double_injection exists" do
         before do
-          @object = Object.new
-          def @object.foobar(*args)
+          def subject.foobar(*args)
             :original_foobar
           end
           @method_name = :foobar
         end
 
         it "returns the existing double_injection" do
-          original_foobar_method = @object.method(:foobar)
-          double_injection = @space.double_injection(@object, 'foobar')
+          original_foobar_method = subject.method(:foobar)
+          @double_injection = space.double_injection(subject, 'foobar')
 
           double_injection.object_has_original_method?.should be_true
 
-          @space.double_injection(@object, 'foobar').should === double_injection
+          space.double_injection(subject, 'foobar').should === double_injection
 
           double_injection.reset
-          @object.foobar.should == :original_foobar
+          subject.foobar.should == :original_foobar
         end
       end
     end
 
     describe "#reset" do
+      attr_reader :subject_1, :subject_2
       before do
-        @space = Space.instance
-        @object1 = Object.new
-        @object2 = Object.new
+        @subject_1 = Object.new
+        @subject_2 = Object.new
         @method_name = :foobar
       end
 
       it "removes the ordered doubles" do
-        double1 = @space.double_injection(@object1, :foobar1)
-        double2 = @space.double_injection(@object1, :foobar2)
-
-        double1 = Double.new(double1)
-        double2 = Double.new(double2)
-
-        double1.ordered
-        double2.ordered
-
-        @space.ordered_doubles.should_not be_empty
-
-        @space.reset
-        @space.ordered_doubles.should be_empty
+        double_1 = new_double(
+          space.double_injection(subject_1, :foobar1),
+          RR::DoubleDefinitions::DoubleDefinition.new(creator = Object.new, subject_1)
+        )
+        double_2 = new_double(
+          space.double_injection(subject_2, :foobar2),
+          RR::DoubleDefinitions::DoubleDefinition.new(creator = Object.new, subject_2)
+        )
+        double_1.ordered
+        double_2.ordered
+
+        space.ordered_doubles.should_not be_empty
+
+        space.reset
+        space.ordered_doubles.should be_empty
       end
 
       it "resets all double_injections" do
-        double1 = @space.double_injection(@object1, @method_name)
-        double1_reset_calls = 0
+        double_1 = space.double_injection(subject_1, method_name)
+        double_1_reset_call_count = 0
         (
-        class << double1;
+        class << double_1;
           self;
         end).class_eval do
           define_method(:reset) do ||
-            double1_reset_calls += 1
+            double_1_reset_call_count += 1
           end
         end
-        double2 = @space.double_injection(@object2, @method_name)
-        double2_reset_calls = 0
+        double_2 = space.double_injection(subject_2, method_name)
+        double_2_reset_call_count = 0
         (
-        class << double2;
+        class << double_2;
           self;
         end).class_eval do
           define_method(:reset) do ||
-            double2_reset_calls += 1
+            double_2_reset_call_count += 1
           end
         end
 
-        @space.reset
-        double1_reset_calls.should == 1
-        double2_reset_calls.should == 1
+        space.reset
+        double_1_reset_call_count.should == 1
+        double_2_reset_call_count.should == 1
       end
     end
 
     describe "#reset_double" do
       before do
-        @space = Space.new
-        @object = Object.new
         @method_name = :foobar
       end
 
       it "resets the double_injections" do
-        double_injection = @space.double_injection(@object, @method_name)
-        @space.double_injections[@object][@method_name].should === double_injection
-        @object.methods.should include("__rr__#{@method_name}")
+        @double_injection = space.double_injection(subject, method_name)
+        space.double_injections[subject][method_name].should === double_injection
+        subject.methods.should include("__rr__#{method_name}")
 
-        @space.reset_double(@object, @method_name)
-        @space.double_injections[@object][@method_name].should be_nil
-        @object.methods.should_not include("__rr__#{@method_name}")
+        space.reset_double(subject, method_name)
+        space.double_injections[subject][method_name].should be_nil
+        subject.methods.should_not include("__rr__#{method_name}")
       end
 
-      it "removes the object from the double_injections map when it has no double_injections" do
-        double1 = @space.double_injection(@object, :foobar1)
-        double2 = @space.double_injection(@object, :foobar2)
+      context "when it has no double_injections" do
+        it "removes the subject from the double_injections map" do
+          double_1 = space.double_injection(subject, :foobar1)
+          double_2 = space.double_injection(subject, :foobar2)
 
-        @space.double_injections.include?(@object).should == true
-        @space.double_injections[@object][:foobar1].should_not be_nil
-        @space.double_injections[@object][:foobar2].should_not be_nil
+          space.double_injections.include?(subject).should == true
+          space.double_injections[subject][:foobar1].should_not be_nil
+          space.double_injections[subject][:foobar2].should_not be_nil
 
-        @space.reset_double(@object, :foobar1)
-        @space.double_injections.include?(@object).should == true
-        @space.double_injections[@object][:foobar1].should be_nil
-        @space.double_injections[@object][:foobar2].should_not be_nil
+          space.reset_double(subject, :foobar1)
+          space.double_injections.include?(subject).should == true
+          space.double_injections[subject][:foobar1].should be_nil
+          space.double_injections[subject][:foobar2].should_not be_nil
 
-        @space.reset_double(@object, :foobar2)
-        @space.double_injections.include?(@object).should == false
+          space.reset_double(subject, :foobar2)
+          space.double_injections.include?(subject).should == false
+        end
       end
     end
 
     describe "#reset_double_injections" do
+      attr_reader :subject_1, :subject_2
       before do
-        @object1 = Object.new
-        @object2 = Object.new
+        @subject_1 = Object.new
+        @subject_2 = Object.new
         @method_name = :foobar
       end
 
       it "resets the double_injection and removes it from the double_injections list" do
-        double1 = @space.double_injection(@object1, @method_name)
-        double1_reset_calls = 0
-        (class << double1; self; end).class_eval do
-          define_method(:reset) do ||
-            double1_reset_calls += 1
+        double_injection_1 = space.double_injection(subject_1, method_name)
+        double_1_reset_call_count = 0
+        (class << double_injection_1; self; end).class_eval do
+          define_method(:reset) do
+            double_1_reset_call_count += 1
           end
         end
-        double2 = @space.double_injection(@object2, @method_name)
-        double2_reset_calls = 0
-        (class << double2; self; end).class_eval do
-          define_method(:reset) do ||
-            double2_reset_calls += 1
+        double_injection_2 = space.double_injection(subject_2, method_name)
+        double_2_reset_call_count = 0
+        (class << double_injection_2; self; end).class_eval do
+          define_method(:reset) do
+            double_2_reset_call_count += 1
           end
         end
 
-        @space.__send__(:reset_double_injections)
-        double1_reset_calls.should == 1
-        double2_reset_calls.should == 1
+        space.__send__(:reset_double_injections)
+        double_1_reset_call_count.should == 1
+        double_2_reset_call_count.should == 1
       end
     end
-    
+
     describe "#register_ordered_double" do
       before(:each) do
-        @object = Object.new
         @method_name = :foobar
-        @double_injection = @space.double_injection(@object, @method_name)
+        @double_injection = space.double_injection(subject, method_name)
       end
 
       it "adds the ordered double to the ordered_doubles collection" do
-        double1 = Double.new(@double_injection)
+        double_1 = new_double
 
-        @space.ordered_doubles.should == []
-        @space.register_ordered_double double1
-        @space.ordered_doubles.should == [double1]
+        space.ordered_doubles.should == []
+        space.register_ordered_double double_1
+        space.ordered_doubles.should == [double_1]
 
-        double2 = Double.new(@double_injection)
-        @space.register_ordered_double double2
-        @space.ordered_doubles.should == [double1, double2]
+        double_2 = new_double
+        space.register_ordered_double double_2
+        space.ordered_doubles.should == [double_1, double_2]
       end
     end
 
     describe "#verify_doubles" do
+      attr_reader :subject_1, :subject_2, :subject3, :double_1, :double_2, :double3
       before do
-        @object1 = Object.new
-        @object2 = Object.new
+        @subject_1 = Object.new
+        @subject_2 = Object.new
+        @subject3 = Object.new
         @method_name = :foobar
+        @double_1 = space.double_injection(subject_1, method_name)
+        @double_2 = space.double_injection(subject_2, method_name)
+        @double3 = space.double_injection(subject3, method_name)
       end
 
-      it "verifies and deletes the double_injections" do
-        double1 = @space.double_injection(@object1, @method_name)
-        double1_verify_calls = 0
-        double1_reset_calls = 0
-        (class << double1; self; end).class_eval do
-          define_method(:verify) do ||
-            double1_verify_calls += 1
+      context "when passed no arguments" do
+        it "verifies and deletes the double_injections" do
+          double_1_verify_call_count = 0
+          double_1_reset_call_count = 0
+          (class << double_1; self; end).class_eval do
+            define_method(:verify) do
+              double_1_verify_call_count += 1
+            end
+            define_method(:reset) do
+              double_1_reset_call_count += 1
+            end
           end
-          define_method(:reset) do ||
-            double1_reset_calls += 1
+
+          double_2_verify_call_count = 0
+          double_2_reset_call_count = 0
+          (class << double_2; self; end).class_eval do
+            define_method(:verify) do
+              double_2_verify_call_count += 1
+            end
+            define_method(:reset) do
+              double_2_reset_call_count += 1
+            end
           end
+
+          space.verify_doubles
+          double_1_verify_call_count.should == 1
+          double_2_verify_call_count.should == 1
+          double_1_reset_call_count.should == 1
+          double_1_reset_call_count.should == 1
         end
-        double2 = @space.double_injection(@object2, @method_name)
-        double2_verify_calls = 0
-        double2_reset_calls = 0
-        (class << double2; self; end).class_eval do
-          define_method(:verify) do ||
-            double2_verify_calls += 1
+      end
+
+      context "when passed an Object that has at least one DoubleInjection" do
+        it "verifies all Doubles injected into the Object" do
+          double_1_verify_call_count = 0
+          double_1_reset_call_count = 0
+          (class << double_1; self; end).class_eval do
+            define_method(:verify) do
+              double_1_verify_call_count += 1
+            end
+            define_method(:reset) do
+              double_1_reset_call_count += 1
+            end
           end
-          define_method(:reset) do ||
-            double2_reset_calls += 1
+
+          double_2_verify_call_count = 0
+          double_2_reset_call_count = 0
+          (class << double_2; self; end).class_eval do
+            define_method(:verify) do
+              double_2_verify_call_count += 1
+            end
+            define_method(:reset) do
+              double_2_reset_call_count += 1
+            end
           end
+
+          space.verify_doubles(subject_1)
+
+          double_1_verify_call_count.should == 1
+          double_1_reset_call_count.should == 1
+          double_2_verify_call_count.should == 0
+          double_2_reset_call_count.should == 0
         end
+      end
+
+      context "when passed multiple Objects with at least one DoubleInjection" do
+        it "verifies the Doubles injected into all of the Objects" do
+          double_1_verify_call_count = 0
+          double_1_reset_call_count = 0
+          (class << double_1; self; end).class_eval do
+            define_method(:verify) do
+              double_1_verify_call_count += 1
+            end
+            define_method(:reset) do
+              double_1_reset_call_count += 1
+            end
+          end
 
-        @space.verify_doubles
-        double1_verify_calls.should == 1
-        double2_verify_calls.should == 1
-        double1_reset_calls.should == 1
-        double1_reset_calls.should == 1
+          double_2_verify_call_count = 0
+          double_2_reset_call_count = 0
+          (class << double_2; self; end).class_eval do
+            define_method(:verify) do
+              double_2_verify_call_count += 1
+            end
+            define_method(:reset) do
+              double_2_reset_call_count += 1
+            end
+          end
+
+          double3_verify_call_count = 0
+          double3_reset_call_count = 0
+          (class << double3; self; end).class_eval do
+            define_method(:verify) do
+              double3_verify_call_count += 1
+            end
+            define_method(:reset) do
+              double3_reset_call_count += 1
+            end
+          end
+
+          space.verify_doubles(subject_1, subject_2)
+
+          double_1_verify_call_count.should == 1
+          double_1_reset_call_count.should == 1
+          double_2_verify_call_count.should == 1
+          double_2_reset_call_count.should == 1
+          double3_verify_call_count.should == 0
+          double3_reset_call_count.should == 0
+        end
+      end
+
+      context "when passed an subject that does not have a DoubleInjection" do
+        it "does not raise an error" do
+          double_1_verify_call_count = 0
+          double_1_reset_call_count = 0
+          (class << double_1; self; end).class_eval do
+            define_method(:verify) do
+              double_1_verify_call_count += 1
+            end
+            define_method(:reset) do
+              double_1_reset_call_count += 1
+            end
+          end
+
+          double_2_verify_call_count = 0
+          double_2_reset_call_count = 0
+          (class << double_2; self; end).class_eval do
+            define_method(:verify) do
+              double_2_verify_call_count += 1
+            end
+            define_method(:reset) do
+              double_2_reset_call_count += 1
+            end
+          end
+
+          double3_verify_call_count = 0
+          double3_reset_call_count = 0
+          (class << double3; self; end).class_eval do
+            define_method(:verify) do
+              double3_verify_call_count += 1
+            end
+            define_method(:reset) do
+              double3_reset_call_count += 1
+            end
+          end
+
+          no_double_injection_object = Object.new
+          space.verify_doubles(no_double_injection_object)
+
+          double_1_verify_call_count.should == 0
+          double_1_reset_call_count.should == 0
+          double_2_verify_call_count.should == 0
+          double_2_reset_call_count.should == 0
+          double3_verify_call_count.should == 0
+          double3_reset_call_count.should == 0
+        end
       end
     end
 
     describe "#verify_double" do
       before do
-        @object = Object.new
         @method_name = :foobar
       end
 
       it "verifies and deletes the double_injection" do
-        double_injection = @space.double_injection(@object, @method_name)
-        @space.double_injections[@object][@method_name].should === double_injection
-        @object.methods.should include("__rr__#{@method_name}")
+        @double_injection = space.double_injection(subject, method_name)
+        space.double_injections[subject][method_name].should === double_injection
+        subject.methods.should include("__rr__#{method_name}")
 
-        verify_calls = 0
+        verify_call_count = 0
         (class << double_injection; self; end).class_eval do
-          define_method(:verify) do ||
-            verify_calls += 1
+          define_method(:verify) do
+            verify_call_count += 1
           end
         end
-        @space.verify_double(@object, @method_name)
-        verify_calls.should == 1
+        space.verify_double(subject, method_name)
+        verify_call_count.should == 1
 
-        @space.double_injections[@object][@method_name].should be_nil
-        @object.methods.should_not include("__rr__#{@method_name}")
+        space.double_injections[subject][method_name].should be_nil
+        subject.methods.should_not include("__rr__#{method_name}")
       end
 
-      it "deletes the double_injection when verifying the double_injection raises an error" do
-        double_injection = @space.double_injection(@object, @method_name)
-        @space.double_injections[@object][@method_name].should === double_injection
-        @object.methods.should include("__rr__#{@method_name}")
-
-        verify_called = true
-        (class << double_injection; self; end).class_eval do
-          define_method(:verify) do ||
-            verify_called = true
-            raise "An Error"
+      context "when verifying the double_injection raises an error" do
+        it "deletes the double_injection" do
+          @double_injection = space.double_injection(subject, method_name)
+          space.double_injections[subject][method_name].should === double_injection
+          subject.methods.should include("__rr__#{method_name}")
+
+          verify_called = true
+          (class << double_injection; self; end).class_eval do
+            define_method(:verify) do
+              verify_called = true
+              raise "An Error"
+            end
           end
-        end
-        lambda {@space.verify_double(@object, @method_name)}.should raise_error
-        verify_called.should be_true
+          lambda {space.verify_double(subject, method_name)}.should raise_error
+          verify_called.should be_true
 
-        @space.double_injections[@object][@method_name].should be_nil
-        @object.methods.should_not include("__rr__#{@method_name}")
+          space.double_injections[subject][method_name].should be_nil
+          subject.methods.should_not include("__rr__#{method_name}")
+        end
       end
     end
 
     describe "#verify_ordered_double" do
       before do
-        @object = Object.new
         @method_name = :foobar
-        @double_injection = @space.double_injection(@object, @method_name)
+        @double_injection = space.double_injection(subject, method_name)
       end
 
-      class << self
-        define_method "#verify_ordered_double" do
-          it "raises an error when Double is NonTerminal" do
-            double = Double.new(@double_injection)
-            @space.register_ordered_double(double)
+      macro "#verify_ordered_double" do
+        it "raises an error when Double is NonTerminal" do
+          double = new_double
+          space.register_ordered_double(double)
 
-            double.any_number_of_times
-            double.should_not be_terminal
+          double.any_number_of_times
+          double.should_not be_terminal
 
-            lambda do
-              @space.verify_ordered_double(double)
-            end.should raise_error(
-            Errors::DoubleOrderError,
-            "Ordered Doubles cannot have a NonTerminal TimesCalledExpectation"
-            )
-          end
+          lambda do
+            space.verify_ordered_double(double)
+          end.should raise_error(
+          Errors::DoubleOrderError,
+          "Ordered Doubles cannot have a NonTerminal TimesCalledExpectation"
+          )
         end
       end
 
       context "when the passed in double is at the front of the queue" do
         send "#verify_ordered_double"
         it "keeps the double when times called is not verified" do
-          double = Double.new(@double_injection)
-          @space.register_ordered_double(double)
+          double = new_double
+          space.register_ordered_double(double)
 
           double.twice
           double.should be_attempt
 
-          @space.verify_ordered_double(double)
-          @space.ordered_doubles.should include(double)
+          space.verify_ordered_double(double)
+          space.ordered_doubles.should include(double)
         end
 
-        it "removes the double when times called expectation should no longer be attempted" do
-          double = Double.new(@double_injection)
-          @space.register_ordered_double(double)
+        context "when Double#attempt? is false" do
+          it "removes the double" do
+            double = new_double
+            space.register_ordered_double(double)
 
-          double.with(1).once
-          @object.foobar(1)
-          double.should_not be_attempt
+            double.with(1).once
+            subject.foobar(1)
+            double.should_not be_attempt
 
-          @space.verify_ordered_double(double)
-          @space.ordered_doubles.should_not include(double)
+            space.verify_ordered_double(double)
+            space.ordered_doubles.should_not include(double)
+          end
         end
       end
 
       context "when the passed in double is not at the front of the queue" do
         send "#verify_ordered_double"
         it "raises error" do
-          first_double = double
-          second_double = double
+          first_double = new_double
+          second_double = new_double
 
           lambda do
-            @space.verify_ordered_double(second_double)
+            space.verify_ordered_double(second_double)
           end.should raise_error(
             Errors::DoubleOrderError,
             "foobar() called out of order in list\n" <<
@@ -374,13 +513,12 @@ module RR
           )
         end
 
-        def double
-          double = Double.new(@double_injection).once
-          @space.register_ordered_double(double.double)
+        def new_double
+          double = super.once
+          space.register_ordered_double(double.double)
           double.double
         end
       end
     end
   end
-
 end