spy 0.0.1 → 0.1.0

data/lib/spy/version.rb

@@ -1,3 +1,3 @@
-class Spy
-  VERSION = "0.0.1"
+module Spy
+  VERSION = "0.1.0"
 end

data/spec/spec_helper.rb

@@ -1,4 +1,6 @@
-require "rspec/autorun"
+require "rspec/core"
+require "rspec/matchers"
+require "rspec/expectations"
 require "spy"
 require "pry"
 require "pry-nav"
@@ -16,7 +18,7 @@ RSpec.configure do |config|
   config.treat_symbols_as_metadata_keys_with_true_values = true
   config.filter_run_including :focus
   config.filter_run_excluding :broken => true
-
+  config.mock_with :absolutely_nothing
 
   config.expect_with :rspec do |expectations|
     expectations.syntax = :expect

data/spec/spy/and_call_original_spec.rb

@@ -133,7 +133,7 @@ describe "and_call_through" do
       end
 
       it 'raises an error on invocation if method_missing does not handle the message' do
-        Spy.new(instance, :not_a_handled_message).hook(force: true).and_call_through
+        Spy::Subroutine.new(instance, :not_a_handled_message).hook(force: true).and_call_through
 
         # Note: it should raise a NoMethodError (and usually does), but
         # due to a weird rspec-expectations issue (see #183) it sometimes

data/spec/spy/and_yield_spec.rb

@@ -1,8 +1,13 @@
 require 'spec_helper'
 
-describe RSpec::Mocks::Mock do
+describe "Spy" do
 
-  let(:obj) { double }
+  class Foo
+    def method_that_accepts_a_block(&block)
+    end
+  end
+
+  let(:obj) { Foo.new }
 
   describe "#and_yield" do
     context "with eval context as block argument" do
@@ -40,30 +45,32 @@ describe RSpec::Mocks::Mock do
 
         it "passes when expectations set on the eval context are met" do
           configured_eval_context = nil
+          context_foo_spy = nil
           Spy.on(obj, :method_that_accepts_a_block).and_yield do |eval_context|
             configured_eval_context = eval_context
-            configured_eval_context.should_receive(:foo)
+            context_foo_spy = Spy::Subroutine.new(configured_eval_context, :foo).hook(force: true)
           end
 
           obj.method_that_accepts_a_block do
             foo
           end
 
-          configured_eval_context.rspec_verify
+          expect(context_foo_spy).to have_been_called
         end
 
         it "fails when expectations set on the eval context are not met" do
           configured_eval_context = nil
+          context_foo_spy = nil
           Spy.on(obj, :method_that_accepts_a_block).and_yield do |eval_context|
             configured_eval_context = eval_context
-            configured_eval_context.should_receive(:foo)
+            context_foo_spy = Spy::Subroutine.new(configured_eval_context, :foo).hook(force: true)
           end
 
           obj.method_that_accepts_a_block do
             # foo is not called here
           end
 
-          expect { configured_eval_context.rspec_verify }.to raise_error(RSpec::Mocks::MockExpectationError)
+          expect(context_foo_spy).to_not have_been_called
         end
 
       end
@@ -73,10 +80,11 @@ describe RSpec::Mocks::Mock do
         it "passes when expectations set on the eval context and yielded arguments are met" do
           configured_eval_context = nil
           yielded_arg = Object.new
+          context_foo_spy = nil
           Spy.on(obj, :method_that_accepts_a_block).and_yield(yielded_arg) do |eval_context|
             configured_eval_context = eval_context
-            configured_eval_context.should_receive(:foo)
-            yielded_arg.should_receive(:bar)
+            context_foo_spy = Spy::Subroutine.new(configured_eval_context, :foo).hook(force: true)
+            Spy::Subroutine.new(yielded_arg, :bar).hook(force: true)
           end
 
           obj.method_that_accepts_a_block do |obj|
@@ -84,17 +92,18 @@ describe RSpec::Mocks::Mock do
             foo
           end
 
-          configured_eval_context.rspec_verify
-          yielded_arg.rspec_verify
+          expect(context_foo_spy).to have_been_called
+          expect(Spy.get(yielded_arg, :bar)).to have_been_called
         end
 
         it "fails when expectations set on the eval context and yielded arguments are not met" do
           configured_eval_context = nil
           yielded_arg = Object.new
+          context_foo_spy = nil
           Spy.on(obj, :method_that_accepts_a_block).and_yield(yielded_arg) do |eval_context|
             configured_eval_context = eval_context
-            configured_eval_context.should_receive(:foo)
-            yielded_arg.should_receive(:bar)
+            context_foo_spy = Spy::Subroutine.new(configured_eval_context, :foo).hook(force: true)
+            Spy::Subroutine.new(yielded_arg, :bar).hook(force: true)
           end
 
           obj.method_that_accepts_a_block do |obj|
@@ -102,8 +111,8 @@ describe RSpec::Mocks::Mock do
             # foo is not called here
           end
 
-          expect { configured_eval_context.rspec_verify }.to raise_error(RSpec::Mocks::MockExpectationError)
-          expect { yielded_arg.rspec_verify }.to raise_error(RSpec::Mocks::MockExpectationError)
+          expect(context_foo_spy).to_not have_been_called
+          expect(Spy.get(yielded_arg, :bar)).to_not have_been_called
         end
 
       end

data/spec/spy/hash_excluding_matcher_spec.rb

@@ -1,66 +1,62 @@
 require 'spec_helper'
 
-module RSpec
-  module Mocks
-    module ArgumentMatchers
-      describe HashExcludingMatcher do
-        
-        it "describes itself properly" do
-          expect(HashExcludingMatcher.new(:a => 5).description).to eq "hash_not_including(:a=>5)"
-        end      
+module Spy
+  describe "Hash excluding matchers", broken: true do
 
-        describe "passing" do
-          it "matches a hash without the specified key" do
-            expect(hash_not_including(:c)).to eq({:a => 1, :b => 2})
-          end
-          
-          it "matches a hash with the specified key, but different value" do
-            expect(hash_not_including(:b => 3)).to eq({:a => 1, :b => 2})
-          end
-                    
-          it "matches a hash without the specified key, given as anything()" do
-            expect(hash_not_including(:c => anything)).to eq({:a => 1, :b => 2})
-          end
+    it "describes itself properly" do
+      expect(HashExcludingMatcher.new(:a => 5).description).to eq "hash_not_including(:a=>5)"
+    end
+
+    describe "passing" do
+      it "matches a hash without the specified key" do
+        expect(hash_not_including(:c)).to eq({:a => 1, :b => 2})
+      end
+
+      it "matches a hash with the specified key, but different value" do
+        expect(hash_not_including(:b => 3)).to eq({:a => 1, :b => 2})
+      end
+
+      it "matches a hash without the specified key, given as anything()" do
+        expect(hash_not_including(:c => anything)).to eq({:a => 1, :b => 2})
+      end
+
+      it "matches an empty hash" do
+        expect(hash_not_including(:a)).to eq({})
+      end
+
+      it "matches a hash without any of the specified keys" do
+        expect(hash_not_including(:a, :b, :c)).to eq(:d => 7)
+      end
+
+    end
+
+    describe "failing" do
+      it "does not match a non-hash" do
+        expect(hash_not_including(:a => 1)).not_to eq 1
+      end
+
+      it "does not match a hash with a specified key" do
+        expect(hash_not_including(:b)).not_to eq(:b => 2)
+      end
+
+      it "does not match a hash with the specified key/value pair" do
+        expect(hash_not_including(:b => 2)).not_to eq(:a => 1, :b => 2)
+      end
+
+      it "does not match a hash with the specified key" do
+        expect(hash_not_including(:a, :b => 3)).not_to eq(:a => 1, :b => 2)
+      end
+
+      it "does not match a hash with one of the specified keys" do
+        expect(hash_not_including(:a, :b)).not_to eq(:b => 2)
+      end
+
+      it "does not match a hash with some of the specified keys" do
+        expect(hash_not_including(:a, :b, :c)).not_to eq(:a => 1, :b => 2)
+      end
 
-          it "matches an empty hash" do
-            expect(hash_not_including(:a)).to eq({})
-          end
-          
-          it "matches a hash without any of the specified keys" do
-            expect(hash_not_including(:a, :b, :c)).to eq(:d => 7)
-          end
-          
-        end
-        
-        describe "failing" do
-          it "does not match a non-hash" do
-            expect(hash_not_including(:a => 1)).not_to eq 1
-          end
-          
-          it "does not match a hash with a specified key" do
-            expect(hash_not_including(:b)).not_to eq(:b => 2)
-          end
-          
-          it "does not match a hash with the specified key/value pair" do
-            expect(hash_not_including(:b => 2)).not_to eq(:a => 1, :b => 2)
-          end
-          
-          it "does not match a hash with the specified key" do
-            expect(hash_not_including(:a, :b => 3)).not_to eq(:a => 1, :b => 2)
-          end
-          
-          it "does not match a hash with one of the specified keys" do
-            expect(hash_not_including(:a, :b)).not_to eq(:b => 2)
-          end
-          
-          it "does not match a hash with some of the specified keys" do
-            expect(hash_not_including(:a, :b, :c)).not_to eq(:a => 1, :b => 2)
-          end
-          
-          it "does not match a hash with one key/value pair included" do
-            expect(hash_not_including(:a, :b, :c, :d => 7)).not_to eq(:d => 7)
-          end
-        end
+      it "does not match a hash with one key/value pair included" do
+        expect(hash_not_including(:a, :b, :c, :d => 7)).not_to eq(:d => 7)
       end
     end
   end

data/spec/spy/hash_including_matcher_spec.rb

@@ -1,90 +1,86 @@
 require 'spec_helper'
 
-module RSpec
-  module Mocks
-    module ArgumentMatchers
-      describe HashIncludingMatcher do
+module Spy
+  describe "Hash including matchers", broken: true do
 
-        it "describes itself properly" do
-          expect(HashIncludingMatcher.new(:a => 1).description).to eq "hash_including(:a=>1)"
-        end
+    it "describes itself properly" do
+      expect(HashIncludingMatcher.new(:a => 1).description).to eq "hash_including(:a=>1)"
+    end
+
+    describe "passing" do
+      it "matches the same hash" do
+        expect(hash_including(:a => 1)).to eq({:a => 1})
+      end
 
-        describe "passing" do
-          it "matches the same hash" do
-            expect(hash_including(:a => 1)).to eq({:a => 1})
-          end
-
-          it "matches a hash with extra stuff" do
-            expect(hash_including(:a => 1)).to eq({:a => 1, :b => 2})
-          end
-
-          describe "when matching against other matchers" do
-            it "matches an int against anything()" do
-              expect(hash_including(:a => anything, :b => 2)).to eq({:a => 1, :b => 2})
-            end
-
-            it "matches a string against anything()" do
-              expect(hash_including(:a => anything, :b => 2)).to eq({:a => "1", :b => 2})
-            end
-          end
-
-          describe "when passed only keys or keys mixed with key/value pairs" do
-            it "matches if the key is present" do
-              expect(hash_including(:a)).to eq({:a => 1, :b => 2})
-            end
-
-            it "matches if more keys are present" do
-              expect(hash_including(:a, :b)).to eq({:a => 1, :b => 2, :c => 3})
-            end
-
-            it "matches a string against a given key" do
-              expect(hash_including(:a)).to eq({:a => "1", :b => 2})
-            end
-
-            it "matches if passed one key and one key/value pair" do
-              expect(hash_including(:a, :b => 2)).to eq({:a => 1, :b => 2})
-            end
-
-            it "matches if passed many keys and one key/value pair" do
-              expect(hash_including(:a, :b, :c => 3)).to eq({:a => 1, :b => 2, :c => 3, :d => 4})
-            end
-
-            it "matches if passed many keys and many key/value pairs" do
-              expect(hash_including(:a, :b, :c => 3, :e => 5)).to eq({:a => 1, :b => 2, :c => 3, :d => 4, :e => 5})
-            end
-          end
+      it "matches a hash with extra stuff" do
+        expect(hash_including(:a => 1)).to eq({:a => 1, :b => 2})
+      end
+
+      describe "when matching against other matchers" do
+        it "matches an int against anything()" do
+          expect(hash_including(:a => anything, :b => 2)).to eq({:a => 1, :b => 2})
         end
 
-        describe "failing" do
-          it "does not match a non-hash" do
-            expect(hash_including(:a => 1)).not_to eq 1
-          end
+        it "matches a string against anything()" do
+          expect(hash_including(:a => anything, :b => 2)).to eq({:a => "1", :b => 2})
+        end
+      end
 
-          it "does not match a hash with a missing key" do
-            expect(hash_including(:a => 1)).not_to eq(:b => 2)
-          end
+      describe "when passed only keys or keys mixed with key/value pairs" do
+        it "matches if the key is present" do
+          expect(hash_including(:a)).to eq({:a => 1, :b => 2})
+        end
 
-          it "does not match a hash with a missing key" do
-            expect(hash_including(:a)).not_to eq(:b => 2)
-          end
+        it "matches if more keys are present" do
+          expect(hash_including(:a, :b)).to eq({:a => 1, :b => 2, :c => 3})
+        end
 
-          it "does not match an empty hash with a given key" do
-            expect(hash_including(:a)).not_to eq({})
-          end
+        it "matches a string against a given key" do
+          expect(hash_including(:a)).to eq({:a => "1", :b => 2})
+        end
 
-          it "does not match a hash with a missing key when one pair is matching" do
-            expect(hash_including(:a, :b => 2)).not_to eq(:b => 2)
-          end
+        it "matches if passed one key and one key/value pair" do
+          expect(hash_including(:a, :b => 2)).to eq({:a => 1, :b => 2})
+        end
 
-          it "does not match a hash with an incorrect value" do
-            expect(hash_including(:a => 1, :b => 2)).not_to eq(:a => 1, :b => 3)
-          end
+        it "matches if passed many keys and one key/value pair" do
+          expect(hash_including(:a, :b, :c => 3)).to eq({:a => 1, :b => 2, :c => 3, :d => 4})
+        end
 
-          it "does not match when values are nil but keys are different" do
-            expect(hash_including(:a => nil)).not_to eq(:b => nil)
-          end
+        it "matches if passed many keys and many key/value pairs" do
+          expect(hash_including(:a, :b, :c => 3, :e => 5)).to eq({:a => 1, :b => 2, :c => 3, :d => 4, :e => 5})
         end
       end
     end
+
+    describe "failing" do
+      it "does not match a non-hash" do
+        expect(hash_including(:a => 1)).not_to eq 1
+      end
+
+      it "does not match a hash with a missing key" do
+        expect(hash_including(:a => 1)).not_to eq(:b => 2)
+      end
+
+      it "does not match a hash with a missing key" do
+        expect(hash_including(:a)).not_to eq(:b => 2)
+      end
+
+      it "does not match an empty hash with a given key" do
+        expect(hash_including(:a)).not_to eq({})
+      end
+
+      it "does not match a hash with a missing key when one pair is matching" do
+        expect(hash_including(:a, :b => 2)).not_to eq(:b => 2)
+      end
+
+      it "does not match a hash with an incorrect value" do
+        expect(hash_including(:a => 1, :b => 2)).not_to eq(:a => 1, :b => 3)
+      end
+
+      it "does not match when values are nil but keys are different" do
+        expect(hash_including(:a => nil)).not_to eq(:b => nil)
+      end
+    end
   end
 end

data/spec/spy/mock_spec.rb

@@ -1,734 +1,730 @@
 require 'spec_helper'
 
-module RSpec
-  module Mocks
-    describe Mock do
-      before(:each) { @double = double("test double") }
-      after(:each)  { @double.rspec_reset }
-
-      it "has method_missing as private" do
-        expect(RSpec::Mocks::Mock.private_instance_methods).to include_method(:method_missing)
-      end
-
-      it "does not respond_to? method_missing (because it's private)" do
-        expect(RSpec::Mocks::Mock.new).not_to respond_to(:method_missing)
-      end
+module Spy
+  describe Double do
+    before(:each) { @double = Spy.double("test double") }
 
-      it "reports line number of expectation of unreceived message" do
-        expected_error_line = __LINE__; @double.should_receive(:wont_happen).with("x", 3)
-        begin
-          @double.rspec_verify
-          violated
-        rescue RSpec::Mocks::MockExpectationError => e
-          # NOTE - this regexp ended w/ $, but jruby adds extra info at the end of the line
-          expect(e.backtrace[0]).to match(/#{File.basename(__FILE__)}:#{expected_error_line}/)
-        end
-      end
+    it "has method_missing as private" do
+      expect(Spy.double("stuff").private_instance_methods).to include_method(:method_missing)
+    end
 
-      it "reports line number of expectation of unreceived message after #should_receive after similar stub" do
-        Spy.on(@double, :wont_happen)
-        expected_error_line = __LINE__; @double.should_receive(:wont_happen).with("x", 3)
-        begin
-          @double.rspec_verify
-          violated
-        rescue RSpec::Mocks::MockExpectationError => e
-          # NOTE - this regexp ended w/ $, but jruby adds extra info at the end of the line
-          expect(e.backtrace[0]).to match(/#{File.basename(__FILE__)}:#{expected_error_line}/)
-        end
-      end
+    it "does not respond_to? method_missing (because it's private)" do
+      expect(Spy.double("stuff")).not_to respond_to(:method_missing)
+    end
 
-      it "passes when not receiving message specified as not to be received" do
-        @double.should_not_receive(:not_expected)
+    it "reports line number of expectation of unreceived message" do
+      expected_error_line = __LINE__; @double.should_receive(:wont_happen).with("x", 3)
+      begin
         @double.rspec_verify
+        violated
+      rescue RSpec::Mocks::MockExpectationError => e
+        # NOTE - this regexp ended w/ $, but jruby adds extra info at the end of the line
+        expect(e.backtrace[0]).to match(/#{File.basename(__FILE__)}:#{expected_error_line}/)
       end
+    end
 
-      it "warns when should_not_receive is followed by and_return" do
-        RSpec::Mocks.should_receive(:warn_deprecation).
-          with(/`and_return` with `should_not_receive` is deprecated/)
-
-        @double.should_not_receive(:do_something).and_return(1)
-      end
-
-      it "passes when receiving message specified as not to be received with different args" do
-        @double.should_not_receive(:message).with("unwanted text")
-        @double.should_receive(:message).with("other text")
-        @double.message "other text"
+    it "reports line number of expectation of unreceived message after #should_receive after similar stub" do
+      Spy.on(@double, :wont_happen)
+      expected_error_line = __LINE__; @double.should_receive(:wont_happen).with("x", 3)
+      begin
         @double.rspec_verify
+        violated
+      rescue RSpec::Mocks::MockExpectationError => e
+        # NOTE - this regexp ended w/ $, but jruby adds extra info at the end of the line
+        expect(e.backtrace[0]).to match(/#{File.basename(__FILE__)}:#{expected_error_line}/)
       end
+    end
 
-      it "fails when receiving message specified as not to be received" do
-        @double.should_not_receive(:not_expected)
-        expect {
-          @double.not_expected
-          violated
-        }.to raise_error(
-          RSpec::Mocks::MockExpectationError,
-          %Q|(Double "test double").not_expected(no args)\n    expected: 0 times\n    received: 1 time|
-        )
-      end
-
-      it "fails when receiving message specified as not to be received with args" do
-        @double.should_not_receive(:not_expected).with("unexpected text")
-        expect {
-          @double.not_expected("unexpected text")
-          violated
-        }.to raise_error(
-          RSpec::Mocks::MockExpectationError,
-          %Q|(Double "test double").not_expected("unexpected text")\n    expected: 0 times\n    received: 1 time|
-        )
-      end
+    it "passes when not receiving message specified as not to be received" do
+      @double.should_not_receive(:not_expected)
+      @double.rspec_verify
+    end
 
-      it "passes when receiving message specified as not to be received with wrong args" do
-        @double.should_not_receive(:not_expected).with("unexpected text")
-        @double.not_expected "really unexpected text"
-        @double.rspec_verify
-      end
+    it "warns when should_not_receive is followed by and_return" do
+      RSpec::Mocks.should_receive(:warn_deprecation).
+        with(/`and_return` with `should_not_receive` is deprecated/)
 
-      it "allows block to calculate return values" do
-        @double.should_receive(:something).with("a","b","c").and_return { |a,b,c| c+b+a }
-        expect(@double.something("a","b","c")).to eq "cba"
-        @double.rspec_verify
-      end
+      @double.should_not_receive(:do_something).and_return(1)
+    end
 
-      it "allows parameter as return value" do
-        @double.should_receive(:something).with("a","b","c").and_return("booh")
-        expect(@double.something("a","b","c")).to eq "booh"
-        @double.rspec_verify
-      end
+    it "passes when receiving message specified as not to be received with different args" do
+      @double.should_not_receive(:message).with("unwanted text")
+      @double.should_receive(:message).with("other text")
+      @double.message "other text"
+      @double.rspec_verify
+    end
 
-      it "returns the previously stubbed value if no return value is set" do
-        Spy.on(@double, :something).with("a","b","c").and_return(:stubbed_value)
-        @double.should_receive(:something).with("a","b","c")
-        expect(@double.something("a","b","c")).to eq :stubbed_value
-        @double.rspec_verify
-      end
+    it "fails when receiving message specified as not to be received" do
+      @double.should_not_receive(:not_expected)
+      expect {
+        @double.not_expected
+        violated
+      }.to raise_error(
+        RSpec::Mocks::MockExpectationError,
+        %Q|(Double "test double").not_expected(no args)\n    expected: 0 times\n    received: 1 time|
+      )
+    end
 
-      it "returns nil if no return value is set and there is no previously stubbed value" do
-        @double.should_receive(:something).with("a","b","c")
-        expect(@double.something("a","b","c")).to be_nil
-        @double.rspec_verify
-      end
+    it "fails when receiving message specified as not to be received with args" do
+      @double.should_not_receive(:not_expected).with("unexpected text")
+      expect {
+        @double.not_expected("unexpected text")
+        violated
+      }.to raise_error(
+        RSpec::Mocks::MockExpectationError,
+        %Q|(Double "test double").not_expected("unexpected text")\n    expected: 0 times\n    received: 1 time|
+      )
+    end
 
-      it "raises exception if args don't match when method called" do
-        @double.should_receive(:something).with("a","b","c").and_return("booh")
-        expect {
-          @double.something("a","d","c")
-          violated
-        }.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" received :something with unexpected arguments\n  expected: (\"a\", \"b\", \"c\")\n       got: (\"a\", \"d\", \"c\")")
-      end
+    it "passes when receiving message specified as not to be received with wrong args" do
+      @double.should_not_receive(:not_expected).with("unexpected text")
+      @double.not_expected "really unexpected text"
+      @double.rspec_verify
+    end
 
-      describe "even when a similar expectation with different arguments exist" do
-        it "raises exception if args don't match when method called, correctly reporting the offending arguments" do
-          @double.should_receive(:something).with("a","b","c").once
-          @double.should_receive(:something).with("z","x","c").once
-          expect {
-            @double.something("a","b","c")
-            @double.something("z","x","g")
-          }.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" received :something with unexpected arguments\n  expected: (\"z\", \"x\", \"c\")\n       got: (\"z\", \"x\", \"g\")")
-        end
-      end
+    it "allows block to calculate return values" do
+      @double.should_receive(:something).with("a","b","c").and_return { |a,b,c| c+b+a }
+      expect(@double.something("a","b","c")).to eq "cba"
+      @double.rspec_verify
+    end
 
-      it "raises exception if args don't match when method called even when the method is stubbed" do
-        Spy.on(@double, :something)
-        @double.should_receive(:something).with("a","b","c")
-        expect {
-          @double.something("a","d","c")
-          @double.rspec_verify
-        }.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" received :something with unexpected arguments\n  expected: (\"a\", \"b\", \"c\")\n       got: (\"a\", \"d\", \"c\")")
-      end
+    it "allows parameter as return value" do
+      @double.should_receive(:something).with("a","b","c").and_return("booh")
+      expect(@double.something("a","b","c")).to eq "booh"
+      @double.rspec_verify
+    end
 
-      it "raises exception if args don't match when method called even when using null_object" do
-        @double = double("test double").as_null_object
-        @double.should_receive(:something).with("a","b","c")
-        expect {
-          @double.something("a","d","c")
-          @double.rspec_verify
-        }.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" received :something with unexpected arguments\n  expected: (\"a\", \"b\", \"c\")\n       got: (\"a\", \"d\", \"c\")")
-      end
+    it "returns the previously stubbed value if no return value is set" do
+      Spy.on(@double, :something).with("a","b","c").and_return(:stubbed_value)
+      @double.should_receive(:something).with("a","b","c")
+      expect(@double.something("a","b","c")).to eq :stubbed_value
+      @double.rspec_verify
+    end
 
-      describe 'with a method that has a default argument' do
-        it "raises an exception if the arguments don't match when the method is called, correctly reporting the offending arguments" do
-          def @double.method_with_default_argument(arg={}); end
-          @double.should_receive(:method_with_default_argument).with({})
+    it "returns nil if no return value is set and there is no previously stubbed value" do
+      @double.should_receive(:something).with("a","b","c")
+      expect(@double.something("a","b","c")).to be_nil
+      @double.rspec_verify
+    end
 
-          expect {
-            @double.method_with_default_argument(nil)
-            @double.rspec_verify
-          }.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" received :method_with_default_argument with unexpected arguments\n  expected: ({})\n       got: (nil)")
-        end
-      end
+    it "raises exception if args don't match when method called" do
+      @double.should_receive(:something).with("a","b","c").and_return("booh")
+      expect {
+        @double.something("a","d","c")
+        violated
+      }.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" received :something with unexpected arguments\n  expected: (\"a\", \"b\", \"c\")\n       got: (\"a\", \"d\", \"c\")")
+    end
 
-      it "fails if unexpected method called" do
+    describe "even when a similar expectation with different arguments exist" do
+      it "raises exception if args don't match when method called, correctly reporting the offending arguments" do
+        @double.should_receive(:something).with("a","b","c").once
+        @double.should_receive(:something).with("z","x","c").once
         expect {
           @double.something("a","b","c")
-          violated
-        }.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" received unexpected message :something with (\"a\", \"b\", \"c\")")
+          @double.something("z","x","g")
+        }.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" received :something with unexpected arguments\n  expected: (\"z\", \"x\", \"c\")\n       got: (\"z\", \"x\", \"g\")")
       end
+    end
 
-      it "uses block for expectation if provided" do
-        @double.should_receive(:something) do | a, b |
-          expect(a).to eq "a"
-          expect(b).to eq "b"
-          "booh"
-        end
-        expect(@double.something("a", "b")).to eq "booh"
+    it "raises exception if args don't match when method called even when the method is stubbed" do
+      Spy.on(@double, :something)
+      @double.should_receive(:something).with("a","b","c")
+      expect {
+        @double.something("a","d","c")
         @double.rspec_verify
-      end
+      }.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" received :something with unexpected arguments\n  expected: (\"a\", \"b\", \"c\")\n       got: (\"a\", \"d\", \"c\")")
+    end
 
-      it "fails if expectation block fails" do
-        @double.should_receive(:something) do |bool|
-          expect(bool).to be_true
-        end
+    it "raises exception if args don't match when method called even when using null_object" do
+      @double = double("test double").as_null_object
+      @double.should_receive(:something).with("a","b","c")
+      expect {
+        @double.something("a","d","c")
+        @double.rspec_verify
+      }.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" received :something with unexpected arguments\n  expected: (\"a\", \"b\", \"c\")\n       got: (\"a\", \"d\", \"c\")")
+    end
+
+    describe 'with a method that has a default argument' do
+      it "raises an exception if the arguments don't match when the method is called, correctly reporting the offending arguments" do
+        def @double.method_with_default_argument(arg={}); end
+        @double.should_receive(:method_with_default_argument).with({})
 
         expect {
-          @double.something false
-        }.to raise_error(RSpec::Expectations::ExpectationNotMetError)
+          @double.method_with_default_argument(nil)
+          @double.rspec_verify
+        }.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" received :method_with_default_argument with unexpected arguments\n  expected: ({})\n       got: (nil)")
       end
+    end
 
-      context "with Ruby > 1.8.6", :unless => RUBY_VERSION.to_s == '1.8.6' do
-        it "passes proc to expectation block without an argument" do
-          # We eval this because Ruby 1.8.6's syntax parser barfs on { |&block| ... }
-          # and prevents the entire spec suite from running.
-          eval("@double.should_receive(:foo) {|&block| expect(block.call).to eq(:bar)}")
-          @double.foo { :bar }
-        end
-
-        it "passes proc to expectation block with an argument" do
-          eval("@double.should_receive(:foo) {|arg, &block| expect(block.call).to eq(:bar)}")
-          @double.foo(:arg) { :bar }
-        end
-
-        it "passes proc to stub block without an argurment" do
-          eval("Spy.on(@double, :foo) {|&block| expect(block.call).to eq(:bar)}")
-          @double.foo { :bar }
-        end
+    it "fails if unexpected method called" do
+      expect {
+        @double.something("a","b","c")
+        violated
+      }.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" received unexpected message :something with (\"a\", \"b\", \"c\")")
+    end
 
-        it "passes proc to stub block with an argument" do
-          eval("Spy.on(@double, :foo) {|arg, &block| expect(block.call).to eq(:bar)}")
-          @double.foo(:arg) { :bar }
-        end
+    it "uses block for expectation if provided" do
+      @double.should_receive(:something) do | a, b |
+        expect(a).to eq "a"
+        expect(b).to eq "b"
+        "booh"
       end
+      expect(@double.something("a", "b")).to eq "booh"
+      @double.rspec_verify
+    end
 
-      it "fails right away when method defined as never is received" do
-        @double.should_receive(:not_expected).never
-        expect { @double.not_expected }.
-          to raise_error(RSpec::Mocks::MockExpectationError,
-                         %Q|(Double "test double").not_expected(no args)\n    expected: 0 times\n    received: 1 time|
-        )
+    it "fails if expectation block fails" do
+      @double.should_receive(:something) do |bool|
+        expect(bool).to be_true
       end
 
-      it "raises RuntimeError by default" do
-        @double.should_receive(:something).and_raise
-        expect { @double.something }.to raise_error(RuntimeError)
-      end
+      expect {
+        @double.something false
+      }.to raise_error(RSpec::Expectations::ExpectationNotMetError)
+    end
 
-      it "raises RuntimeError with a message by default" do
-        @double.should_receive(:something).and_raise("error message")
-        expect { @double.something }.to raise_error(RuntimeError, "error message")
+    context "with Ruby > 1.8.6", :unless => RUBY_VERSION.to_s == '1.8.6' do
+      it "passes proc to expectation block without an argument" do
+        # We eval this because Ruby 1.8.6's syntax parser barfs on { |&block| ... }
+        # and prevents the entire spec suite from running.
+        eval("@double.should_receive(:foo) {|&block| expect(block.call).to eq(:bar)}")
+        @double.foo { :bar }
       end
 
-      it "raises an exception of a given type without an error message" do
-        @double.should_receive(:something).and_raise(StandardError)
-        expect { @double.something }.to raise_error(StandardError)
+      it "passes proc to expectation block with an argument" do
+        eval("@double.should_receive(:foo) {|arg, &block| expect(block.call).to eq(:bar)}")
+        @double.foo(:arg) { :bar }
       end
 
-      it "raises an exception of a given type with a message" do
-        @double.should_receive(:something).and_raise(RuntimeError, "error message")
-        expect { @double.something }.to raise_error(RuntimeError, "error message")
+      it "passes proc to stub block without an argurment" do
+        eval("Spy.on(@double, :foo) {|&block| expect(block.call).to eq(:bar)}")
+        @double.foo { :bar }
       end
 
-      it "raises a given instance of an exception" do
-        @double.should_receive(:something).and_raise(RuntimeError.new("error message"))
-        expect { @double.something }.to raise_error(RuntimeError, "error message")
+      it "passes proc to stub block with an argument" do
+        eval("Spy.on(@double, :foo) {|arg, &block| expect(block.call).to eq(:bar)}")
+        @double.foo(:arg) { :bar }
       end
+    end
 
-      class OutOfGas < StandardError
-        attr_reader :amount, :units
-        def initialize(amount, units)
-          @amount = amount
-          @units  = units
-        end
-      end
+    it "fails right away when method defined as never is received" do
+      @double.should_receive(:not_expected).never
+      expect { @double.not_expected }.
+        to raise_error(RSpec::Mocks::MockExpectationError,
+                       %Q|(Double "test double").not_expected(no args)\n    expected: 0 times\n    received: 1 time|
+                      )
+    end
 
-      it "raises a given instance of an exception with arguments other than the standard 'message'" do
-        @double.should_receive(:something).and_raise(OutOfGas.new(2, :oz))
+    it "raises RuntimeError by default" do
+      @double.should_receive(:something).and_raise
+      expect { @double.something }.to raise_error(RuntimeError)
+    end
 
-        begin
-          @double.something
-          fail "OutOfGas was not raised"
-        rescue OutOfGas => e
-          expect(e.amount).to eq 2
-          expect(e.units).to eq :oz
-        end
-      end
+    it "raises RuntimeError with a message by default" do
+      @double.should_receive(:something).and_raise("error message")
+      expect { @double.something }.to raise_error(RuntimeError, "error message")
+    end
 
-      it "does not raise when told to if args dont match" do
-        @double.should_receive(:something).with(2).and_raise(RuntimeError)
-        expect {
-          @double.something 1
-        }.to raise_error(RSpec::Mocks::MockExpectationError)
-      end
+    it "raises an exception of a given type without an error message" do
+      @double.should_receive(:something).and_raise(StandardError)
+      expect { @double.something }.to raise_error(StandardError)
+    end
 
-      it "throws when told to" do
-        @double.should_receive(:something).and_throw(:blech)
-        expect {
-          @double.something
-        }.to throw_symbol(:blech)
-      end
+    it "raises an exception of a given type with a message" do
+      @double.should_receive(:something).and_raise(RuntimeError, "error message")
+      expect { @double.something }.to raise_error(RuntimeError, "error message")
+    end
 
-      it "ignores args on any args" do
-        @double.should_receive(:something).at_least(:once).with(any_args)
-        @double.something
-        @double.something 1
-        @double.something "a", 2
-        @double.something [], {}, "joe", 7
-        @double.rspec_verify
-      end
+    it "raises a given instance of an exception" do
+      @double.should_receive(:something).and_raise(RuntimeError.new("error message"))
+      expect { @double.something }.to raise_error(RuntimeError, "error message")
+    end
 
-      it "fails on no args if any args received" do
-        @double.should_receive(:something).with(no_args())
-        expect {
-          @double.something 1
-        }.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" received :something with unexpected arguments\n  expected: (no args)\n       got: (1)")
+    class OutOfGas < StandardError
+      attr_reader :amount, :units
+      def initialize(amount, units)
+        @amount = amount
+        @units  = units
       end
+    end
 
-      it "fails when args are expected but none are received" do
-        @double.should_receive(:something).with(1)
-        expect {
-          @double.something
-        }.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" received :something with unexpected arguments\n  expected: (1)\n       got: (no args)")
-      end
+    it "raises a given instance of an exception with arguments other than the standard 'message'" do
+      @double.should_receive(:something).and_raise(OutOfGas.new(2, :oz))
 
-      it "returns value from block by default" do
-        Spy.on(@double, :method_that_yields).and_yield
-        value = @double.method_that_yields { :returned_obj }
-        expect(value).to eq :returned_obj
-        @double.rspec_verify
+      begin
+        @double.something
+        fail "OutOfGas was not raised"
+      rescue OutOfGas => e
+        expect(e.amount).to eq 2
+        expect(e.units).to eq :oz
       end
+    end
 
-      it "yields 0 args to blocks that take a variable number of arguments" do
-        @double.should_receive(:yield_back).with(no_args()).once.and_yield
-        a = nil
-        @double.yield_back {|*x| a = x}
-        expect(a).to eq []
-        @double.rspec_verify
-      end
+    it "does not raise when told to if args dont match" do
+      @double.should_receive(:something).with(2).and_raise(RuntimeError)
+      expect {
+        @double.something 1
+      }.to raise_error(RSpec::Mocks::MockExpectationError)
+    end
 
-      it "yields 0 args multiple times to blocks that take a variable number of arguments" do
-        @double.should_receive(:yield_back).once.with(no_args()).once.and_yield.
-                                                                    and_yield
-        b = []
-        @double.yield_back {|*a| b << a}
-        expect(b).to eq [ [], [] ]
-        @double.rspec_verify
-      end
+    it "throws when told to" do
+      @double.should_receive(:something).and_throw(:blech)
+      expect {
+        @double.something
+      }.to throw_symbol(:blech)
+    end
 
-      it "yields one arg to blocks that take a variable number of arguments" do
-        @double.should_receive(:yield_back).with(no_args()).once.and_yield(99)
-        a = nil
-        @double.yield_back {|*x| a = x}
-        expect(a).to eq [99]
-        @double.rspec_verify
-      end
+    it "ignores args on any args" do
+      @double.should_receive(:something).at_least(:once).with(any_args)
+      @double.something
+      @double.something 1
+      @double.something "a", 2
+      @double.something [], {}, "joe", 7
+      @double.rspec_verify
+    end
 
-      it "yields one arg 3 times consecutively to blocks that take a variable number of arguments" do
-        @double.should_receive(:yield_back).once.with(no_args()).once.and_yield(99).
-                                                                    and_yield(43).
-                                                                    and_yield("something fruity")
-        b = []
-        @double.yield_back {|*a| b << a}
-        expect(b).to eq [[99], [43], ["something fruity"]]
-        @double.rspec_verify
-      end
+    it "fails on no args if any args received" do
+      @double.should_receive(:something).with(no_args())
+      expect {
+        @double.something 1
+      }.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" received :something with unexpected arguments\n  expected: (no args)\n       got: (1)")
+    end
 
-      it "yields many args to blocks that take a variable number of arguments" do
-        @double.should_receive(:yield_back).with(no_args()).once.and_yield(99, 27, "go")
-        a = nil
-        @double.yield_back {|*x| a = x}
-        expect(a).to eq [99, 27, "go"]
-        @double.rspec_verify
-      end
+    it "fails when args are expected but none are received" do
+      @double.should_receive(:something).with(1)
+      expect {
+        @double.something
+      }.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" received :something with unexpected arguments\n  expected: (1)\n       got: (no args)")
+    end
 
-      it "yields many args 3 times consecutively to blocks that take a variable number of arguments" do
-        @double.should_receive(:yield_back).once.with(no_args()).once.and_yield(99, :green, "go").
-                                                                    and_yield("wait", :amber).
-                                                                    and_yield("stop", 12, :red)
-        b = []
-        @double.yield_back {|*a| b << a}
-        expect(b).to eq [[99, :green, "go"], ["wait", :amber], ["stop", 12, :red]]
-        @double.rspec_verify
-      end
+    it "returns value from block by default" do
+      Spy.on(@double, :method_that_yields).and_yield
+      value = @double.method_that_yields { :returned_obj }
+      expect(value).to eq :returned_obj
+      @double.rspec_verify
+    end
 
-      it "yields single value" do
-        @double.should_receive(:yield_back).with(no_args()).once.and_yield(99)
-        a = nil
-        @double.yield_back {|x| a = x}
-        expect(a).to eq 99
-        @double.rspec_verify
-      end
+    it "yields 0 args to blocks that take a variable number of arguments" do
+      @double.should_receive(:yield_back).with(no_args()).once.and_yield
+      a = nil
+      @double.yield_back {|*x| a = x}
+      expect(a).to eq []
+      @double.rspec_verify
+    end
 
-      it "yields single value 3 times consecutively" do
-        @double.should_receive(:yield_back).once.with(no_args()).once.and_yield(99).
-                                                                    and_yield(43).
-                                                                    and_yield("something fruity")
-        b = []
-        @double.yield_back {|a| b << a}
-        expect(b).to eq [99, 43, "something fruity"]
-        @double.rspec_verify
-      end
+    it "yields 0 args multiple times to blocks that take a variable number of arguments" do
+      @double.should_receive(:yield_back).once.with(no_args()).once.and_yield.
+        and_yield
+      b = []
+      @double.yield_back {|*a| b << a}
+      expect(b).to eq [ [], [] ]
+      @double.rspec_verify
+    end
 
-      it "yields two values" do
-        @double.should_receive(:yield_back).with(no_args()).once.and_yield('wha', 'zup')
-        a, b = nil
-        @double.yield_back {|x,y| a=x; b=y}
-        expect(a).to eq 'wha'
-        expect(b).to eq 'zup'
-        @double.rspec_verify
-      end
+    it "yields one arg to blocks that take a variable number of arguments" do
+      @double.should_receive(:yield_back).with(no_args()).once.and_yield(99)
+      a = nil
+      @double.yield_back {|*x| a = x}
+      expect(a).to eq [99]
+      @double.rspec_verify
+    end
 
-      it "yields two values 3 times consecutively" do
-        @double.should_receive(:yield_back).once.with(no_args()).once.and_yield('wha', 'zup').
-                                                                    and_yield('not', 'down').
-                                                                    and_yield(14, 65)
-        c = []
-        @double.yield_back {|a,b| c << [a, b]}
-        expect(c).to eq [['wha', 'zup'], ['not', 'down'], [14, 65]]
-        @double.rspec_verify
-      end
+    it "yields one arg 3 times consecutively to blocks that take a variable number of arguments" do
+      @double.should_receive(:yield_back).once.with(no_args()).once.and_yield(99).
+        and_yield(43).
+        and_yield("something fruity")
+      b = []
+      @double.yield_back {|*a| b << a}
+      expect(b).to eq [[99], [43], ["something fruity"]]
+      @double.rspec_verify
+    end
 
-      it "fails when calling yielding method with wrong arity" do
-        @double.should_receive(:yield_back).with(no_args()).once.and_yield('wha', 'zup')
-        expect {
-          @double.yield_back {|a|}
-        }.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" yielded |\"wha\", \"zup\"| to block with arity of 1")
-      end
+    it "yields many args to blocks that take a variable number of arguments" do
+      @double.should_receive(:yield_back).with(no_args()).once.and_yield(99, 27, "go")
+      a = nil
+      @double.yield_back {|*x| a = x}
+      expect(a).to eq [99, 27, "go"]
+      @double.rspec_verify
+    end
 
-      it "fails when calling yielding method consecutively with wrong arity" do
-        @double.should_receive(:yield_back).once.with(no_args()).once.and_yield('wha', 'zup').
-                                                                    and_yield('down').
-                                                                    and_yield(14, 65)
-        expect {
-          c = []
-          @double.yield_back {|a,b| c << [a, b]}
-        }.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" yielded |\"down\"| to block with arity of 2")
-      end
+    it "yields many args 3 times consecutively to blocks that take a variable number of arguments" do
+      @double.should_receive(:yield_back).once.with(no_args()).once.and_yield(99, :green, "go").
+        and_yield("wait", :amber).
+        and_yield("stop", 12, :red)
+      b = []
+      @double.yield_back {|*a| b << a}
+      expect(b).to eq [[99, :green, "go"], ["wait", :amber], ["stop", 12, :red]]
+      @double.rspec_verify
+    end
 
-      it "fails when calling yielding method without block" do
-        @double.should_receive(:yield_back).with(no_args()).once.and_yield('wha', 'zup')
-        expect {
-          @double.yield_back
-        }.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" asked to yield |[\"wha\", \"zup\"]| but no block was passed")
-      end
+    it "yields single value" do
+      @double.should_receive(:yield_back).with(no_args()).once.and_yield(99)
+      a = nil
+      @double.yield_back {|x| a = x}
+      expect(a).to eq 99
+      @double.rspec_verify
+    end
 
-      it "is able to double send" do
-        @double.should_receive(:send).with(any_args)
-        @double.send 'hi'
-        @double.rspec_verify
-      end
+    it "yields single value 3 times consecutively" do
+      @double.should_receive(:yield_back).once.with(no_args()).once.and_yield(99).
+        and_yield(43).
+        and_yield("something fruity")
+      b = []
+      @double.yield_back {|a| b << a}
+      expect(b).to eq [99, 43, "something fruity"]
+      @double.rspec_verify
+    end
 
-      it "is able to raise from method calling yielding double" do
-        @double.should_receive(:yield_me).and_yield 44
+    it "yields two values" do
+      @double.should_receive(:yield_back).with(no_args()).once.and_yield('wha', 'zup')
+      a, b = nil
+      @double.yield_back {|x,y| a=x; b=y}
+      expect(a).to eq 'wha'
+      expect(b).to eq 'zup'
+      @double.rspec_verify
+    end
 
-        expect {
-          @double.yield_me do |x|
-            raise "Bang"
-          end
-        }.to raise_error(StandardError, "Bang")
+    it "yields two values 3 times consecutively" do
+      @double.should_receive(:yield_back).once.with(no_args()).once.and_yield('wha', 'zup').
+        and_yield('not', 'down').
+        and_yield(14, 65)
+      c = []
+      @double.yield_back {|a,b| c << [a, b]}
+      expect(c).to eq [['wha', 'zup'], ['not', 'down'], [14, 65]]
+      @double.rspec_verify
+    end
 
-        @double.rspec_verify
-      end
+    it "fails when calling yielding method with wrong arity" do
+      @double.should_receive(:yield_back).with(no_args()).once.and_yield('wha', 'zup')
+      expect {
+        @double.yield_back {|a|}
+      }.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" yielded |\"wha\", \"zup\"| to block with arity of 1")
+    end
 
-      it "clears expectations after verify" do
-        @double.should_receive(:foobar)
-        @double.foobar
-        @double.rspec_verify
-        expect {
-          @double.foobar
-        }.to raise_error(RSpec::Mocks::MockExpectationError, %q|Double "test double" received unexpected message :foobar with (no args)|)
-      end
+    it "fails when calling yielding method consecutively with wrong arity" do
+      @double.should_receive(:yield_back).once.with(no_args()).once.and_yield('wha', 'zup').
+        and_yield('down').
+        and_yield(14, 65)
+      expect {
+        c = []
+        @double.yield_back {|a,b| c << [a, b]}
+      }.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" yielded |\"down\"| to block with arity of 2")
+    end
 
-      it "restores objects to their original state on rspec_reset" do
-        double = double("this is a double")
-        double.should_receive(:blah)
-        double.rspec_reset
-        double.rspec_verify #should throw if reset didn't work
-      end
+    it "fails when calling yielding method without block" do
+      @double.should_receive(:yield_back).with(no_args()).once.and_yield('wha', 'zup')
+      expect {
+        @double.yield_back
+      }.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" asked to yield |[\"wha\", \"zup\"]| but no block was passed")
+    end
 
-      it "works even after method_missing starts raising NameErrors instead of NoMethodErrors" do
-        # Object#method_missing throws either NameErrors or NoMethodErrors.
-        #
-        # On a fresh ruby program Object#method_missing:
-        #  * raises a NoMethodError when called directly
-        #  * raises a NameError when called indirectly
-        #
-        # Once Object#method_missing has been called at least once (on any object)
-        # it starts behaving differently:
-        #  * raises a NameError when called directly
-        #  * raises a NameError when called indirectly
-        #
-        # There was a bug in Mock#method_missing that relied on the fact
-        # that calling Object#method_missing directly raises a NoMethodError.
-        # This example tests that the bug doesn't exist anymore.
+    it "is able to double send" do
+      @double.should_receive(:send).with(any_args)
+      @double.send 'hi'
+      @double.rspec_verify
+    end
 
+    it "is able to raise from method calling yielding double" do
+      @double.should_receive(:yield_me).and_yield 44
 
-        # Ensures that method_missing always raises NameErrors.
-        a_method_that_doesnt_exist rescue
+      expect {
+        @double.yield_me do |x|
+          raise "Bang"
+        end
+      }.to raise_error(StandardError, "Bang")
 
+      @double.rspec_verify
+    end
 
-        @double.should_receive(:foobar)
+    it "clears expectations after verify" do
+      @double.should_receive(:foobar)
+      @double.foobar
+      @double.rspec_verify
+      expect {
         @double.foobar
-        @double.rspec_verify
+      }.to raise_error(RSpec::Mocks::MockExpectationError, %q|Double "test double" received unexpected message :foobar with (no args)|)
+    end
 
-        expect { @double.foobar }.to_not raise_error(NameError)
-        expect { @double.foobar }.to raise_error(RSpec::Mocks::MockExpectationError)
-      end
+    it "restores objects to their original state on rspec_reset" do
+      double = double("this is a double")
+      double.should_receive(:blah)
+      double.rspec_reset
+      double.rspec_verify #should throw if reset didn't work
+    end
 
-      it "temporarily replaces a method stub on a double" do
-        Spy.on(@double, :msg).and_return(:stub_value)
-        @double.should_receive(:msg).with(:arg).and_return(:double_value)
-        expect(@double.msg(:arg)).to equal(:double_value)
-        expect(@double.msg).to equal(:stub_value)
-        expect(@double.msg).to equal(:stub_value)
-        @double.rspec_verify
-      end
+    it "works even after method_missing starts raising NameErrors instead of NoMethodErrors" do
+      # Object#method_missing throws either NameErrors or NoMethodErrors.
+      #
+      # On a fresh ruby program Object#method_missing:
+      #  * raises a NoMethodError when called directly
+      #  * raises a NameError when called indirectly
+      #
+      # Once Object#method_missing has been called at least once (on any object)
+      # it starts behaving differently:
+      #  * raises a NameError when called directly
+      #  * raises a NameError when called indirectly
+      #
+      # There was a bug in Mock#method_missing that relied on the fact
+      # that calling Object#method_missing directly raises a NoMethodError.
+      # This example tests that the bug doesn't exist anymore.
+
+
+      # Ensures that method_missing always raises NameErrors.
+      a_method_that_doesnt_exist rescue
+
+
+      @double.should_receive(:foobar)
+      @double.foobar
+      @double.rspec_verify
+
+      expect { @double.foobar }.to_not raise_error(NameError)
+      expect { @double.foobar }.to raise_error(RSpec::Mocks::MockExpectationError)
+    end
 
-      it "does not require a different signature to replace a method stub" do
-        Spy.on(@double, :msg).and_return(:stub_value)
-        @double.should_receive(:msg).and_return(:double_value)
-        expect(@double.msg(:arg)).to equal(:double_value)
-        expect(@double.msg).to equal(:stub_value)
-        expect(@double.msg).to equal(:stub_value)
-        @double.rspec_verify
-      end
+    it "temporarily replaces a method stub on a double" do
+      Spy.on(@double, :msg).and_return(:stub_value)
+      @double.should_receive(:msg).with(:arg).and_return(:double_value)
+      expect(@double.msg(:arg)).to equal(:double_value)
+      expect(@double.msg).to equal(:stub_value)
+      expect(@double.msg).to equal(:stub_value)
+      @double.rspec_verify
+    end
 
-      it "raises an error when a previously stubbed method has a negative expectation" do
-        Spy.on(@double, :msg).and_return(:stub_value)
-        @double.should_not_receive(:msg)
-        expect { @double.msg(:arg) }.to raise_error(RSpec::Mocks::MockExpectationError)
-      end
+    it "does not require a different signature to replace a method stub" do
+      Spy.on(@double, :msg).and_return(:stub_value)
+      @double.should_receive(:msg).and_return(:double_value)
+      expect(@double.msg(:arg)).to equal(:double_value)
+      expect(@double.msg).to equal(:stub_value)
+      expect(@double.msg).to equal(:stub_value)
+      @double.rspec_verify
+    end
 
-      it "temporarily replaces a method stub on a non-double" do
-        non_double = Object.new
-        Spy.on(non_double, :msg).and_return(:stub_value)
-        non_double.should_receive(:msg).with(:arg).and_return(:double_value)
-        expect(non_double.msg(:arg)).to equal(:double_value)
-        expect(non_double.msg).to equal(:stub_value)
-        expect(non_double.msg).to equal(:stub_value)
-        non_double.rspec_verify
-      end
+    it "raises an error when a previously stubbed method has a negative expectation" do
+      Spy.on(@double, :msg).and_return(:stub_value)
+      @double.should_not_receive(:msg)
+      expect { @double.msg(:arg) }.to raise_error(RSpec::Mocks::MockExpectationError)
+    end
 
-      it "returns the stubbed value when no new value specified" do
-        Spy.on(@double, :msg).and_return(:stub_value)
-        @double.should_receive(:msg)
-        expect(@double.msg).to equal(:stub_value)
-        @double.rspec_verify
-      end
+    it "temporarily replaces a method stub on a non-double" do
+      non_double = Object.new
+      Spy.on(non_double, :msg).and_return(:stub_value)
+      non_double.should_receive(:msg).with(:arg).and_return(:double_value)
+      expect(non_double.msg(:arg)).to equal(:double_value)
+      expect(non_double.msg).to equal(:stub_value)
+      expect(non_double.msg).to equal(:stub_value)
+      non_double.rspec_verify
+    end
 
-      it "returns the stubbed value when stubbed with args and no new value specified" do
-        Spy.on(@double, :msg).with(:arg).and_return(:stub_value)
-        @double.should_receive(:msg).with(:arg)
-        expect(@double.msg(:arg)).to equal(:stub_value)
-        @double.rspec_verify
-      end
+    it "returns the stubbed value when no new value specified" do
+      Spy.on(@double, :msg).and_return(:stub_value)
+      @double.should_receive(:msg)
+      expect(@double.msg).to equal(:stub_value)
+      @double.rspec_verify
+    end
 
-      it "does not mess with the stub's yielded values when also doubleed" do
-        Spy.on(@double, :yield_back).and_yield(:stub_value)
-        @double.should_receive(:yield_back).and_yield(:double_value)
-        @double.yield_back{|v| expect(v).to eq :double_value }
-        @double.yield_back{|v| expect(v).to eq :stub_value }
-        @double.rspec_verify
-      end
+    it "returns the stubbed value when stubbed with args and no new value specified" do
+      Spy.on(@double, :msg).with(:arg).and_return(:stub_value)
+      @double.should_receive(:msg).with(:arg)
+      expect(@double.msg(:arg)).to equal(:stub_value)
+      @double.rspec_verify
+    end
 
-      it "yields multiple values after a similar stub" do
-        FSpy.on(ile, :open).and_yield(:stub_value)
-        File.should_receive(:open).and_yield(:first_call).and_yield(:second_call)
-        yielded_args = []
-        File.open {|v| yielded_args << v }
-        expect(yielded_args).to eq [:first_call, :second_call]
-        File.open {|v| expect(v).to eq :stub_value }
-        File.rspec_verify
-      end
+    it "does not mess with the stub's yielded values when also doubleed" do
+      Spy.on(@double, :yield_back).and_yield(:stub_value)
+      @double.should_receive(:yield_back).and_yield(:double_value)
+      @double.yield_back{|v| expect(v).to eq :double_value }
+      @double.yield_back{|v| expect(v).to eq :stub_value }
+      @double.rspec_verify
+    end
 
-      it "assigns stub return values" do
-        double = RSpec::Mocks::Mock.new('name', :message => :response)
-        expect(double.message).to eq :response
-      end
+    it "yields multiple values after a similar stub" do
+      FSpy.on(ile, :open).and_yield(:stub_value)
+      File.should_receive(:open).and_yield(:first_call).and_yield(:second_call)
+      yielded_args = []
+      File.open {|v| yielded_args << v }
+      expect(yielded_args).to eq [:first_call, :second_call]
+      File.open {|v| expect(v).to eq :stub_value }
+      File.rspec_verify
+    end
 
+    it "assigns stub return values" do
+      double = Spy.double('name', :message => :response)
+      expect(double.message).to eq :response
     end
 
-    describe "a double message receiving a block" do
-      before(:each) do
-        @double = double("double")
-        @calls = 0
-      end
+  end
 
-      def add_call
-        @calls = @calls + 1
-      end
+  describe "a double message receiving a block" do
+    before(:each) do
+      @double = Spy.double("double")
+      @calls = 0
+    end
 
-      it "calls the block after #should_receive" do
-        @double.should_receive(:foo) { add_call }
+    def add_call
+      @calls = @calls + 1
+    end
 
-        @double.foo
+    it "calls the block after #should_receive" do
+      @double.should_receive(:foo) { add_call }
 
-        expect(@calls).to eq 1
-      end
+      @double.foo
 
-      it "calls the block after #should_receive after a similar stub" do
-        Spy.on(@double, :foo).and_return(:bar)
-        @double.should_receive(:foo) { add_call }
+      expect(@calls).to eq 1
+    end
 
-        @double.foo
+    it "calls the block after #should_receive after a similar stub" do
+      Spy.on(@double, :foo).and_return(:bar)
+      @double.should_receive(:foo) { add_call }
 
-        expect(@calls).to eq 1
-      end
+      @double.foo
 
-      it "calls the block after #once" do
-        @double.should_receive(:foo).once { add_call }
+      expect(@calls).to eq 1
+    end
 
-        @double.foo
+    it "calls the block after #once" do
+      @double.should_receive(:foo).once { add_call }
 
-        expect(@calls).to eq 1
-      end
+      @double.foo
 
-      it "calls the block after #twice" do
-        @double.should_receive(:foo).twice { add_call }
+      expect(@calls).to eq 1
+    end
 
-        @double.foo
-        @double.foo
+    it "calls the block after #twice" do
+      @double.should_receive(:foo).twice { add_call }
 
-        expect(@calls).to eq 2
-      end
+      @double.foo
+      @double.foo
 
-      it "calls the block after #times" do
-        @double.should_receive(:foo).exactly(10).times { add_call }
+      expect(@calls).to eq 2
+    end
 
-        (1..10).each { @double.foo }
+    it "calls the block after #times" do
+      @double.should_receive(:foo).exactly(10).times { add_call }
 
-        expect(@calls).to eq 10
-      end
+      (1..10).each { @double.foo }
+
+      expect(@calls).to eq 10
+    end
 
-      it "calls the block after #any_number_of_times" do
-        @double.should_receive(:foo).any_number_of_times { add_call }
+    it "calls the block after #any_number_of_times" do
+      @double.should_receive(:foo).any_number_of_times { add_call }
 
-        (1..7).each { @double.foo }
+      (1..7).each { @double.foo }
 
-        expect(@calls).to eq 7
-      end
+      expect(@calls).to eq 7
+    end
 
-      it "calls the block after #ordered" do
-        @double.should_receive(:foo).ordered { add_call }
-        @double.should_receive(:bar).ordered { add_call }
+    it "calls the block after #ordered" do
+      @double.should_receive(:foo).ordered { add_call }
+      @double.should_receive(:bar).ordered { add_call }
 
-        @double.foo
-        @double.bar
+      @double.foo
+      @double.bar
 
-        expect(@calls).to eq 2
-      end
+      expect(@calls).to eq 2
     end
+  end
 
-    describe 'string representation generated by #to_s' do
-      it 'does not contain < because that might lead to invalid HTML in some situations' do
-        double = double("Dog")
-        valid_html_str = "#{double}"
-        expect(valid_html_str).not_to include('<')
-      end
+  describe 'string representation generated by #to_s' do
+    it 'does not contain < because that might lead to invalid HTML in some situations' do
+      double = Spy.double("Dog")
+      valid_html_str = "#{double}"
+      expect(valid_html_str).not_to include('<')
     end
+  end
 
-    describe "string representation generated by #to_str" do
-      it "looks the same as #to_s" do
-        double = double("Foo")
-        expect(double.to_str).to eq double.to_s
-      end
+  describe "string representation generated by #to_str" do
+    it "looks the same as #to_s" do
+      double = Spy.double("Foo")
+      expect(double.to_str).to eq double.to_s
     end
+  end
 
-    describe "double created with no name" do
-      it "does not use a name in a failure message" do
-        double = double()
-        expect {double.foo}.to raise_error(/Double received/)
-      end
+  describe "double created with no name" do
+    it "does not use a name in a failure message" do
+      double = Spy.double()
+      expect {double.foo}.to raise_error(/Double received/)
+    end
 
-      it "does respond to initially stubbed methods" do
-        double = double(:foo => "woo", :bar => "car")
-        expect(double.foo).to eq "woo"
-        expect(double.bar).to eq "car"
-      end
+    it "does respond to initially stubbed methods" do
+      double = Spy.double(:foo => "woo", :bar => "car")
+      expect(double.foo).to eq "woo"
+      expect(double.bar).to eq "car"
     end
+  end
 
-    describe "==" do
-      it "sends '== self' to the comparison object" do
-        first = double('first')
-        second = double('second')
+  describe "==" do
+    it "sends '== self' to the comparison object" do
+      first = Spy.double('first')
+      second = Spy.double('second')
 
-        first.should_receive(:==).with(second)
-        second == first
-      end
+      first.should_receive(:==).with(second)
+      second == first
     end
+  end
 
-    describe "with" do
-      before { @double = double('double') }
-      context "with args" do
-        context "with matching args" do
-          it "passes" do
-            @double.should_receive(:foo).with('bar')
-            @double.foo('bar')
-          end
+  describe "with" do
+    before { @double = Spy.double('double') }
+    context "with args" do
+      context "with matching args" do
+        it "passes" do
+          @double.should_receive(:foo).with('bar')
+          @double.foo('bar')
         end
+      end
 
-        context "with non-matching args" do
-          it "fails" do
-            @double.should_receive(:foo).with('bar')
-            expect do
-              @double.foo('baz')
-            end.to raise_error
-            @double.rspec_reset
-          end
+      context "with non-matching args" do
+        it "fails" do
+          @double.should_receive(:foo).with('bar')
+          expect do
+            @double.foo('baz')
+          end.to raise_error
+          @double.rspec_reset
         end
+      end
 
-        context "with non-matching doubles" do
-          it "fails" do
-            d1 = double('1')
-            d2 = double('2')
-            @double.should_receive(:foo).with(d1)
-            expect do
-              @double.foo(d2)
-            end.to raise_error
-            @double.rspec_reset
-          end
+      context "with non-matching doubles" do
+        it "fails" do
+          d1 = Spy.double('1')
+          d2 = Spy.double('2')
+          @double.should_receive(:foo).with(d1)
+          expect do
+            @double.foo(d2)
+          end.to raise_error
+          @double.rspec_reset
         end
+      end
 
-        context "with non-matching doubles as_null_object" do
-          it "fails" do
-            d1 = double('1').as_null_object
-            d2 = double('2').as_null_object
-            @double.should_receive(:foo).with(d1)
-            expect do
-              @double.foo(d2)
-            end.to raise_error
-            @double.rspec_reset
-          end
+      context "with non-matching doubles as_null_object" do
+        it "fails" do
+          d1 = Spy.double('1').as_null_object
+          d2 = Spy.double('2').as_null_object
+          @double.should_receive(:foo).with(d1)
+          expect do
+            @double.foo(d2)
+          end.to raise_error
+          @double.rspec_reset
         end
       end
+    end
 
-      context "with a block" do
-        context "with matching args" do
-          it "returns the result of the block" do
-            @double.should_receive(:foo).with('bar') { 'baz' }
-            expect(@double.foo('bar')).to eq('baz')
-          end
+    context "with a block" do
+      context "with matching args" do
+        it "returns the result of the block" do
+          @double.should_receive(:foo).with('bar') { 'baz' }
+          expect(@double.foo('bar')).to eq('baz')
         end
+      end
 
-        context "with non-matching args" do
-          it "fails" do
-            @double.should_receive(:foo).with('bar') { 'baz' }
-            expect do
-              expect(@double.foo('wrong')).to eq('baz')
-            end.to raise_error(/received :foo with unexpected arguments/)
-            @double.rspec_reset
-          end
+      context "with non-matching args" do
+        it "fails" do
+          @double.should_receive(:foo).with('bar') { 'baz' }
+          expect do
+            expect(@double.foo('wrong')).to eq('baz')
+          end.to raise_error(/received :foo with unexpected arguments/)
+          @double.rspec_reset
         end
       end
     end
-
   end
 end