rspec-mocks 3.0.0.beta1 → 3.0.0.beta2

data/spec/rspec/mocks/example_methods_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe ExampleMethods do
+      it 'does not define private helper methods since it gets included into a ' +
+         'namespace where users define methods and could inadvertently overwrite ' +
+         'them' do
+        expect(ExampleMethods.private_instance_methods).to eq([])
+      end
+    end
+  end
+end

data/spec/rspec/mocks/extensions/marshal_spec.rb

@@ -13,23 +13,6 @@ describe Marshal, 'extensions' do
   end
 
   describe '#dump' do
-    context 'when rspec-mocks has not been fully initialized' do
-      def without_space
-        stashed_space, RSpec::Mocks.space = RSpec::Mocks.space, nil
-        yield
-      ensure
-        RSpec::Mocks.space = stashed_space
-      end
-
-      it 'does not duplicate the object before serialization' do
-        obj = UndupableObject.new
-        without_space do
-          serialized = Marshal.dump(obj)
-          expect(Marshal.load(serialized)).to be_an(UndupableObject)
-        end
-      end
-    end
-
     context 'when rspec-mocks has been fully initialized' do
       it 'duplicates objects with stubbed or mocked implementations before serialization' do
         obj = double(:foo => "bar")
@@ -50,5 +33,22 @@ describe Marshal, 'extensions' do
         expect(Marshal.load(serialized)).to be_nil
       end
     end
+
+    context 'outside the per-test lifecycle' do
+      def outside_per_test_lifecycle
+        RSpec::Mocks.teardown
+        yield
+      ensure
+        RSpec::Mocks.setup
+      end
+
+      it 'does not duplicate the object before serialization' do
+        obj = UndupableObject.new
+        outside_per_test_lifecycle do
+          serialized = Marshal.dump(obj)
+          expect(Marshal.load(serialized)).to be_an(UndupableObject)
+        end
+      end
+    end
   end
 end

data/spec/rspec/mocks/failing_argument_matchers_spec.rb

@@ -63,9 +63,11 @@ module RSpec
       end
 
       it "matches against a Matcher" do
+        # This spec is generating warnings on 1.8.7, not sure why so
+        # this does with_isolated_stderr to kill them. @samphippen 3rd Jan 2013.
         expect do
           @double.should_receive(:msg).with(equal(3))
-          @double.msg(37)
+          with_isolated_stderr { @double.msg(37) }
         end.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"double\" received :msg with unexpected arguments\n  expected: (equal 3)\n       got: (37)")
       end
 
@@ -103,6 +105,17 @@ module RSpec
         end.to raise_error(ArgumentError, /must have at least one argument/)
       end
 
+      it "fails when given an arbitrary object that returns false from #===" do
+        matcher = double
+        matcher.should_receive(:===).with(4).at_least(:once).and_return(false)
+
+        @double.should_receive(:foo).with(matcher)
+
+        expect {
+          @double.foo(4)
+        }.to raise_error(RSpec::Mocks::MockExpectationError)
+      end
+
       it "fails with sensible message when args respond to #description" do
         arg = Class.new do
           def description
@@ -151,6 +164,21 @@ module RSpec
           @double.msg 3
         end.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"double\" received :msg with unexpected arguments\n  expected: (my_thing)\n       got: (3)")
       end
+
+      it "fails a class against an unrelated class" do
+        @double.should_receive(:foo).with(Fixnum)
+        expect {
+          @double.foo(Hash)
+        }.to raise_error(RSpec::Mocks::MockExpectationError)
+      end
+
+      it "fails a class against an object of a different type" do
+        @double.should_receive(:foo).with(Fixnum)
+
+        expect {
+          @double.foo(3.2)
+        }.to raise_error(RSpec::Mocks::MockExpectationError)
+      end
     end
   end
 end

data/spec/rspec/mocks/hash_excluding_matcher_spec.rb

@@ -11,54 +11,54 @@ module RSpec
 
         describe "passing" do
           it "matches a hash without the specified key" do
-            expect(hash_not_including(:c)).to eq({:a => 1, :b => 2})
+            expect(hash_not_including(:c)).to be === {: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})
+            expect(hash_not_including(:b => 3)).to be === {: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})
+            expect(hash_not_including(:c => anything)).to be === {:a => 1, :b => 2}
           end
 
           it "matches an empty hash" do
-            expect(hash_not_including(:a)).to eq({})
+            expect(hash_not_including(:a)).to be === {}
           end
 
           it "matches a hash without any of the specified keys" do
-            expect(hash_not_including(:a, :b, :c)).to eq(:d => 7)
+            expect(hash_not_including(:a, :b, :c)).to be === { :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
+            expect(hash_not_including(:a => 1)).not_to be === 1
           end
 
           it "does not match a hash with a specified key" do
-            expect(hash_not_including(:b)).not_to eq(:b => 2)
+            expect(hash_not_including(:b)).not_to be === { :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)
+            expect(hash_not_including(:b => 2)).not_to be === { :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)
+            expect(hash_not_including(:a, :b => 3)).not_to be === { :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)
+            expect(hash_not_including(:a, :b)).not_to be === { :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)
+            expect(hash_not_including(:a, :b, :c)).not_to be === { :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)
+            expect(hash_not_including(:a, :b, :c, :d => 7)).not_to be === { :d => 7 }
           end
         end
       end

data/spec/rspec/mocks/hash_including_matcher_spec.rb

@@ -11,77 +11,81 @@ module RSpec
 
         describe "passing" do
           it "matches the same hash" do
-            expect(hash_including(:a => 1)).to eq({:a => 1})
+            expect(hash_including(:a => 1)).to be === {:a => 1}
           end
 
           it "matches a hash with extra stuff" do
-            expect(hash_including(:a => 1)).to eq({:a => 1, :b => 2})
+            expect(hash_including(:a => 1)).to be === {: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})
+              expect(hash_including(:a => anything, :b => 2)).to be === {: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})
+              expect(hash_including(:a => anything, :b => 2)).to be === {:a => "1", :b => 2}
+            end
+
+            it 'can match against arbitrary objects that implement #===' do
+              expect(hash_including(:a => /foo/)).to be === { :a => "foobar" }
             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})
+              expect(hash_including(:a)).to be === {: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})
+              expect(hash_including(:a, :b)).to be === {: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})
+              expect(hash_including(:a)).to be === {: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})
+              expect(hash_including(:a, :b => 2)).to be === {: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})
+              expect(hash_including(:a, :b, :c => 3)).to be === {: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})
+              expect(hash_including(:a, :b, :c => 3, :e => 5)).to be === {: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
+            expect(hash_including(:a => 1)).not_to be === 1
           end
 
           it "does not match a hash with a missing key" do
-            expect(hash_including(:a => 1)).not_to eq(:b => 2)
+            expect(hash_including(:a => 1)).not_to be === { :b => 2 }
           end
 
           it "does not match a hash with a missing key" do
-            expect(hash_including(:a)).not_to eq(:b => 2)
+            expect(hash_including(:a)).not_to be === { :b => 2 }
           end
 
           it "does not match an empty hash with a given key" do
-            expect(hash_including(:a)).not_to eq({})
+            expect(hash_including(:a)).not_to be === {}
           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)
+            expect(hash_including(:a, :b => 2)).not_to be === { :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)
+            expect(hash_including(:a => 1, :b => 2)).not_to be === { :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)
+            expect(hash_including(:a => nil)).not_to be === { :b => nil }
           end
         end
       end

data/spec/rspec/mocks/instance_method_stasher_spec.rb

@@ -24,7 +24,7 @@ module RSpec
         stashed_method = stasher_for(obj, :hello)
         stashed_method.stash
 
-        def obj.hello; :overridden_hello; end
+        with_isolated_stderr { def obj.hello; :overridden_hello; end }
         expect(obj.hello).to eql :overridden_hello
 
         stashed_method.restore
@@ -39,7 +39,7 @@ module RSpec
         stashed_method = stasher_for(obj, :hello)
         stashed_method.stash
 
-        def obj.hello; :overridden_hello; end
+        with_isolated_stderr { def obj.hello; :overridden_hello; end }
         stashed_method.restore
         expect(obj.send(:hello)).to eql :hello_defined_on_singleton_class
       end
@@ -72,4 +72,3 @@ module RSpec
     end
   end
 end
-

data/spec/rspec/mocks/matchers/have_received_spec.rb

@@ -132,6 +132,13 @@ module RSpec
           expect(matcher.description).to eq 'have received expected_method(:expected_args) 1 time'
         end
 
+        it 'can generate a description after mocks have been torn down (e.g. when rspec-core requests it)' do
+          matcher = have_received(:expected_method).with(:expected_args).once
+          matcher.matches?(double(:expected_method => 1))
+          RSpec::Mocks.teardown
+          expect(matcher.description).to eq 'have received expected_method(:expected_args) 1 time'
+        end
+
         context "counts" do
           let(:dbl) { double(:expected_method => nil) }
 

data/spec/rspec/mocks/matchers/receive_message_chain_spec.rb

@@ -0,0 +1,198 @@
+require "spec_helper"
+
+
+module RSpec::Mocks::Matchers
+  describe "receive_message_chain" do
+    let(:object) { double(:object) }
+
+    context "with only the expect syntax enabled" do
+      include_context "with syntax", :expect
+
+      it "errors with a negative allowance" do
+        expect {
+          allow(object).not_to receive_message_chain(:to_a)
+        }.to raise_error(RSpec::Mocks::NegationUnsupportedError)
+      end
+
+      it "errors with a negative expectation" do
+        expect {
+          expect(object).not_to receive_message_chain(:to_a)
+        }.to raise_error(RSpec::Mocks::NegationUnsupportedError)
+      end
+
+      it "errors with a negative any_instance expectation" do
+        expect {
+          expect_any_instance_of(Object).not_to receive_message_chain(:to_a)
+        }.to raise_error(RSpec::Mocks::NegationUnsupportedError)
+      end
+
+      it "errors with a negative any_instance allowance" do
+        expect {
+          allow_any_instance_of(Object).not_to receive_message_chain(:to_a)
+        }.to raise_error(RSpec::Mocks::NegationUnsupportedError)
+      end
+
+      it "works with a do block" do
+        allow(object).to receive_message_chain(:to_a, :length) do
+          3
+        end
+
+        expect(object.to_a.length).to eq(3)
+      end
+
+      it "works with a {} block" do
+        allow(object).to receive_message_chain(:to_a, :length) { 3 }
+
+        expect(object.to_a.length).to eq(3)
+      end
+
+      it "gives the { } block prescedence over the do block" do
+        allow(object).to receive_message_chain(:to_a, :length) { 3 } do
+          4
+        end
+
+        expect(object.to_a.length).to eq(3)
+      end
+
+      it "works with and_return" do
+        allow(object).to receive_message_chain(:to_a, :length).and_return(3)
+
+        expect(object.to_a.length).to eq(3)
+      end
+
+      it "works with and_call_original", :pending => "See https://github.com/rspec/rspec-mocks/pull/467#issuecomment-28631621" do
+        list = [1, 2, 3]
+        expect(list).to receive_message_chain(:to_a, :length).and_call_original
+        expect(list.to_a.length).to eq(3)
+      end
+
+      it "fails with and_call_original when the entire chain is not called", :pending => "See https://github.com/rspec/rspec-mocks/pull/467#issuecomment-28631621" do
+        list = [1, 2, 3]
+        expect(list).to receive_message_chain(:to_a, :length).and_call_original
+        expect(list.to_a).to eq([1, 2, 3])
+      end
+
+      it "works with and_raise" do
+        allow(object).to receive_message_chain(:to_a, :length).and_raise(StandardError.new("hi"))
+
+        expect { object.to_a.length }.to raise_error(StandardError, "hi")
+      end
+
+      it "works with and_throw" do
+        allow(object).to receive_message_chain(:to_a, :length).and_throw(:nope)
+
+        expect { object.to_a.length }.to throw_symbol(:nope)
+      end
+
+      it "works with and_yield" do
+        allow(object).to receive_message_chain(:to_a, :length).and_yield(3)
+
+        expect { |blk| object.to_a.length(&blk) }.to yield_with_args(3)
+      end
+
+      it "works with a string of messages to chain" do
+        allow(object).to receive_message_chain("to_a.length").and_yield(3)
+
+        expect { |blk| object.to_a.length(&blk) }.to yield_with_args(3)
+      end
+
+      it "works with a hash return as the last argument in the chain" do
+        allow(object).to receive_message_chain(:to_a, :length => 3)
+
+        expect(object.to_a.length).to eq(3)
+      end
+
+      it "accepts any number of arguments to the stubbed messages" do
+        allow(object).to receive_message_chain(:msg1, :msg2).and_return(:return_value)
+
+        expect(object.msg1("nonsense", :value).msg2("another", :nonsense, 3.0, "value")).to eq(:return_value)
+      end
+
+      it "accepts any number of arguments to the stubbed messages with an inline hash return value" do
+        allow(object).to receive_message_chain(:msg1, :msg2 => :return_value)
+
+        expect(object.msg1("nonsense", :value).msg2("another", :nonsense, 3.0, "value")).to eq(:return_value)
+      end
+
+      it "raises when expect is used and the entire chain isn't called" do
+        expect {
+          expect(object).to receive_message_chain(:to_a, :farce, :length => 3)
+          object.to_a
+          verify_all
+        }.to raise_error(RSpec::Mocks::MockExpectationError)
+      end
+
+      it "does not raise when expect is used and the entire chain is called" do
+        expect {
+          expect(object).to receive_message_chain(:to_a, :length => 3)
+          object.to_a.length
+          verify_all
+        }.not_to raise_error
+      end
+
+      it "works with allow_any_instance" do
+        o = Object.new
+
+        allow_any_instance_of(Object).to receive_message_chain(:to_a, :length => 3)
+
+        expect(o.to_a.length).to eq(3)
+      end
+
+      it "fails when with expect_any_instance_of is used and the entire chain is not called" do
+        expect {
+          expect_any_instance_of(Object).to receive_message_chain(:to_a, :length => 3)
+          verify_all
+        }.to raise_error(RSpec::Mocks::MockExpectationError)
+      end
+
+      it "passes when with expect_any_instance_of is used and the entire chain is called" do
+        o = Object.new
+
+        expect_any_instance_of(Object).to receive_message_chain(:to_a, :length => 3)
+        o.to_a.length
+      end
+
+      it "works with expect where the first level of the chain is already expected" do
+        o = Object.new
+        expect(o).to receive(:foo).and_return(double)
+        expect(o).to receive_message_chain(:foo, :bar, :baz)
+
+        o.foo.bar.baz
+      end
+
+      it "works with allow where the first level of the chain is already expected" do
+        o = Object.new
+        expect(o).to receive(:foo).and_return(double)
+        allow(o).to receive_message_chain(:foo, :bar, :baz).and_return(3)
+
+        expect(o.foo.bar.baz).to eq(3)
+      end
+
+      it "works with expect where the first level of the chain is already stubbed" do
+        o = Object.new
+        allow(o).to receive(:foo).and_return(double)
+        expect(o).to receive_message_chain(:foo, :bar, :baz)
+
+        o.foo.bar.baz
+      end
+
+      it "works with allow where the first level of the chain is already stubbed" do
+        o = Object.new
+        allow(o).to receive(:foo).and_return(double)
+        allow(o).to receive_message_chain(:foo, :bar, :baz).and_return(3)
+
+        expect(o.foo.bar.baz).to eq(3)
+      end
+    end
+
+    context "when the expect and should syntaxes are enabled" do
+      include_context "with syntax", [:expect, :should]
+
+      it "stubs the message correctly" do
+        allow(object).to receive_message_chain(:to_a, :length)
+
+        expect { object.to_a.length }.not_to raise_error
+      end
+    end
+  end
+end