rspec-mocks 2.99.4 → 3.0.0.beta1

data/spec/rspec/mocks/configuration_spec.rb

@@ -85,6 +85,11 @@ module RSpec
             expect(configured_syntax).to eq([:should])
           end
 
+          it "does not warn about the should syntax" do
+            RSpec.should_not_receive(:deprecate)
+            Object.new.should_not_receive(:bees)
+          end
+
           it 'is a no-op when configured a second time' do
             Syntax.default_should_syntax_host.should_not_receive(:method_added)
             ::RSpec::Mocks::ExampleMethods.should_not_receive(:method_undefined)
@@ -110,6 +115,68 @@ module RSpec
           it 'reports that both syntaxes are enabled' do
             expect(configured_syntax).to eq([:should, :expect])
           end
+
+          it "does not warn about the should syntax" do
+            RSpec.should_not_receive(:deprecate)
+            Object.new.should_not_receive(:bees)
+          end
+        end
+
+        context "by default" do
+          before do
+            configure_default_syntax
+          end
+
+          let(:expected_arguments) {
+            [
+              /Using.*without explicitly enabling/,
+              {:replacement=>"the new `:expect` syntax or explicitly enable `:should`"}
+            ]
+          }
+
+          it "it warns about should once, regardless of how many times it is called" do
+            expect(RSpec).to receive(:deprecate).with(*expected_arguments)
+            o = Object.new
+            o2 = Object.new
+            o.should_receive(:bees)
+            o2.should_receive(:bees)
+
+            o.bees
+            o2.bees
+          end
+
+          it "warns about should not once, regardless of how many times it is called" do
+            expect(RSpec).to receive(:deprecate).with(*expected_arguments)
+            o = Object.new
+            o2 = Object.new
+            o.should_not_receive(:bees)
+            o2.should_not_receive(:bees)
+          end
+
+          it "warns about stubbing once, regardless of how many times it is called" do
+            expect(RSpec).to receive(:deprecate).with(*expected_arguments)
+            o = Object.new
+            o2 = Object.new
+
+            o.stub(:faces)
+            o2.stub(:faces)
+          end
+
+          it "doesn't warn about stubbing after a reset and setting should" do
+            expect(RSpec).not_to receive(:deprecate)
+            RSpec::Mocks.configuration.reset_syntaxes_to_default
+            RSpec::Mocks.configuration.syntax = :should
+            o = Object.new
+            o2 = Object.new
+            o.stub(:faces)
+            o2.stub(:faces)
+          end
+
+          it "includes the call site in the deprecation warning" do
+            obj = Object.new
+            expect_deprecation_with_call_site(__FILE__, __LINE__ + 1)
+            obj.stub(:faces)
+          end
         end
       end
 
@@ -122,6 +189,10 @@ module RSpec
           def configured_syntax
             RSpec::Mocks.configuration.syntax
           end
+
+          def configure_default_syntax
+            RSpec::Mocks.configuration.reset_syntaxes_to_default
+          end
         end
       end
 
@@ -142,6 +213,14 @@ module RSpec
               end
             end
           end
+
+          def configure_default_syntax
+            RSpec.configure do |rspec|
+              rspec.mock_with :rspec do |c|
+                c.reset_syntaxes_to_default
+              end
+            end
+          end
         end
       end
     end

data/spec/rspec/mocks/double_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 
 describe "double" do
   it "is an alias for stub and mock" do
-    expect(double()).to be_a(RSpec::Mocks::Double)
+    expect(double()).to be_a(RSpec::Mocks::Mock)
   end
 
   it "uses 'Double' in failure messages" do
@@ -10,16 +10,16 @@ describe "double" do
     expect {double.foo}.to raise_error(/Double "name" received/)
   end
 
-  describe "deprecated aliases" do
-    it "warns if #stub is used" do
-      expect(RSpec).to receive(:deprecate).with("stub", :replacement => "double")
-      stub("TestDouble")
-    end
+  it "hides internals in its inspect representation" do
+    m = double('cup')
+    expect(m.inspect).to match(/#<RSpec::Mocks::Mock:0x[a-f0-9.]+ @name="cup">/)
+  end
 
-    it "warns if #mock is used" do
-      expect(RSpec).to receive(:deprecate).with("mock", :replacement => "double")
-      mock("TestDouble")
-    end
+  it 'restores standard object methods on reset' do
+    dbl = double(:tainted? => true)
+    expect(dbl.tainted?).to eq(true)
+    reset dbl
+    expect(dbl.tainted?).to eq(false)
   end
 
   it 'does not get string vs symbol messages confused' do
@@ -28,72 +28,4 @@ describe "double" do
     expect(dbl.foo).to eq(2)
     expect { reset dbl }.not_to raise_error
   end
-
-  context "after it has been torn down" do
-    let(:dbl) { double }
-
-    before do
-      expect(dbl).to receive(:foo).at_least(:once)
-      allow(dbl).to receive(:bar)
-      dbl.foo
-
-      RSpec::Mocks.verify
-      RSpec::Mocks.teardown
-      RSpec::Mocks.setup
-    end
-
-    it 'warns when stubbing new methods (with receive)' do
-      expect_deprecation_with_call_site(__FILE__, __LINE__ + 1)
-      allow(dbl).to receive(:bazz).and_return(3)
-      expect(dbl.bazz).to eq(3)
-    end
-
-    it 'warns when mocking new methods' do
-      expect_deprecation_with_call_site(__FILE__, __LINE__ + 1)
-      expect(dbl).to receive(:bazz)
-      dbl.bazz
-    end
-
-    it 'warns when turned into a null object' do
-      expect_deprecation_with_call_site(__FILE__, __LINE__ + 1)
-      dbl.as_null_object
-      dbl.foo.bar.bazz.goo
-    end
-
-    it 'warns when checked for nullness' do
-      expect_deprecation_with_call_site(__FILE__, __LINE__ + 1)
-      dbl.null_object?
-    end
-  end
-
-  context 'when frozen' do
-    it 'warns of deprecation' do
-      expect_deprecation_with_call_site(__FILE__, __LINE__ + 1)
-      double.freeze
-    end
-
-    it 'is really frozen' do
-      expect(double.freeze).to be_frozen
-    end
-  end
-
-  context 'when it has turned into a null object and been frozen' do
-    before do
-      double.as_null_object.freeze
-    end
-
-    context 'on tearing down' do
-      it 'does not raise error' do
-        expect { RSpec::Mocks.verify }.not_to raise_error
-      end
-    end
-  end
-
-  context 'when being deserialized from YAML' do
-    let(:yaml) { YAML.dump(double) }
-
-    it 'does not raise error' do
-      expect { YAML.load(yaml) }.not_to raise_error
-    end
-  end
 end

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

@@ -31,21 +31,13 @@ describe Marshal, 'extensions' do
     end
 
     context 'when rspec-mocks has been fully initialized' do
-      include_context 'with isolated configuration'
-
       it 'duplicates objects with stubbed or mocked implementations before serialization' do
-        RSpec::Mocks.configuration.patch_marshal_to_support_partial_doubles = true
         obj = double(:foo => "bar")
 
         serialized = Marshal.dump(obj)
         expect(Marshal.load(serialized)).to be_an(obj.class)
       end
 
-      it 'provides a deprecation warning' do
-        expect_warn_deprecation_with_call_site('marshal_spec.rb', __LINE__ + 1)
-        Marshal.dump double(:foo => "bar")
-      end
-
       it 'does not duplicate other objects before serialization' do
         obj = UndupableObject.new
 

data/spec/rspec/mocks/failing_argument_matchers_spec.rb

@@ -83,12 +83,24 @@ module RSpec
          end.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"double\" received :msg with unexpected arguments\n  expected: (hash_including(:a=>1))\n       got: ({})")
       end
 
-      it "fails with block matchers" do
-        allow_deprecation
+      it "fails array_including when args aren't array" do
+         expect do
+           @double.should_receive(:msg).with(array_including(1,2,3))
+           @double.msg(1,2,3)
+         end.to raise_error(/array_including\(1,2,3\)/)
+      end
+
+      it "fails array_including when arg doesn't contain all elements" do
+         expect do
+           @double.should_receive(:msg).with(array_including(1,2,3))
+           @double.msg(1,2)
+         end.to raise_error(/array_including\(1,2,3\)/)
+      end
+
+      it "fails with zero arguments" do
         expect do
           @double.should_receive(:msg).with {|arg| expect(arg).to eq :received }
-          @double.msg :no_msg_for_you
-        end.to raise_error(RSpec::Expectations::ExpectationNotMetError, /expected: :received.*\s*.*got: :no_msg_for_you/)
+        end.to raise_error(ArgumentError, /must have at least one argument/)
       end
 
       it "fails with sensible message when args respond to #description" do
@@ -106,6 +118,39 @@ module RSpec
           @double.msg arg
         end.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"double\" received :msg with unexpected arguments\n  expected: (3)\n       got: (my_thing)")
       end
+
+      it "fails with sensible message when arg#description is nil" do
+        arg = Class.new do
+          def description
+          end
+
+          def inspect
+            "my_thing"
+          end
+        end.new
+
+        expect do
+          @double.should_receive(:msg).with(arg)
+          @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 with sensible message when arg#description is blank" do
+        arg = Class.new do
+          def description
+            ""
+          end
+
+          def inspect
+            "my_thing"
+          end
+        end.new
+
+        expect do
+          @double.should_receive(:msg).with(arg)
+          @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
     end
   end
 end

data/spec/rspec/mocks/instance_method_stasher_spec.rb

@@ -13,11 +13,15 @@ module RSpec
         class << obj; self; end
       end
 
+      def stasher_for(obj, method_name)
+        InstanceMethodStasher.new(obj, method_name)
+      end
+
       it "stashes the current implementation of an instance method so it can be temporarily replaced" do
         obj = Object.new
         def obj.hello; :hello_defined_on_singleton_class; end;
 
-        stashed_method = InstanceMethodStasher.new(singleton_class_for(obj), :hello)
+        stashed_method = stasher_for(obj, :hello)
         stashed_method.stash
 
         def obj.hello; :overridden_hello; end
@@ -32,7 +36,7 @@ module RSpec
         def obj.hello; :hello_defined_on_singleton_class; end;
         singleton_class_for(obj).__send__(:private, :hello)
 
-        stashed_method = InstanceMethodStasher.new(singleton_class_for(obj), :hello)
+        stashed_method = stasher_for(obj, :hello)
         stashed_method.stash
 
         def obj.hello; :overridden_hello; end
@@ -43,7 +47,7 @@ module RSpec
       it "only stashes methods directly defined on the given class, not its ancestors" do
         obj = ExampleClass.new
 
-        stashed_method = InstanceMethodStasher.new(singleton_class_for(obj), :hello)
+        stashed_method = stasher_for(obj, :hello)
         stashed_method.stash
 
         def obj.hello; :overridden_hello; end;
@@ -52,6 +56,19 @@ module RSpec
         stashed_method.restore
         expect(obj.hello).to eql :overridden_hello
       end
+
+      it "does not unnecessarily create obfuscated aliased methods", :if => (RUBY_VERSION.to_f > 1.8) do
+        obj = Object.new
+        def obj.hello; :hello_defined_on_singleton_class; end;
+
+        stashed_method = stasher_for(obj, :hello)
+
+        expect {
+          stashed_method.stash
+        }.not_to change { obj.methods.count }
+
+        expect(obj.methods.grep(/rspec/)).to eq([])
+      end
     end
   end
 end

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

@@ -48,6 +48,58 @@ module RSpec
           }.to raise_error(/method has been mocked instead of stubbed/)
         end
 
+        it "takes a curly-bracket block and yields the arguments given to the stubbed method call" do
+          dbl = double(:foo => nil)
+          yielded = []
+          dbl.foo(:a, :b, :c)
+          expect(dbl).to have_received(:foo) { |*args|
+            yielded << args
+          }
+          expect(yielded).to include([:a,:b,:c])
+        end
+
+        it "takes a do-end block and yields the arguments given to the stubbed method call" do
+          dbl = double(:foo => nil)
+          yielded = []
+          dbl.foo(:a, :b, :c)
+          expect(dbl).to have_received(:foo) do |*args|
+            yielded << args
+          end
+          expect(yielded).to include([:a,:b,:c])
+        end
+
+        it "passes if expectations against the yielded arguments pass" do
+          dbl = double(:foo => nil)
+          dbl.foo(42)
+          expect {
+            expect(dbl).to have_received(:foo) { |arg|
+              expect(arg).to eq(42)
+            }
+          }.to_not raise_error
+        end
+
+        it "fails if expectations against the yielded arguments fail" do
+          dbl = double(:foo => nil)
+          dbl.foo(43)
+          expect {
+            expect(dbl).to have_received(:foo) { |arg|
+              expect(arg).to eq(42)
+            }
+          }.to raise_error(RSpec::Expectations::ExpectationNotMetError)
+        end
+
+        it 'gives precedence to a `{ ... }` block when both forms are provided ' +
+           'since that form actually binds to `receive`' do
+          dbl = double(:foo => nil)
+          called = []
+          dbl.foo
+          expect(dbl).to have_received(:foo) { called << :curly } do
+            called << :do_end
+          end
+          expect(called).to include(:curly)
+          expect(called).not_to include(:do_end)
+        end
+
         it 'resets expectations on class methods when mocks are reset' do
           dbl = Object
           dbl.stub(:expected_method)
@@ -195,6 +247,28 @@ module RSpec
             end
           end
         end
+
+        context 'ordered' do
+          let(:dbl) { double :one => 1, :two => 2 }
+
+          it 'passes when the messages were received in order' do
+            dbl.one
+            dbl.two
+
+            expect(dbl).to have_received(:one).ordered
+            expect(dbl).to have_received(:two).ordered
+          end
+
+          it 'fails when the messages are received out of order' do
+            dbl.two
+            dbl.one
+
+            expect {
+              expect(dbl).to have_received(:one).ordered
+              expect(dbl).to have_received(:two).ordered
+            }.to raise_error(/received :two out of order/m)
+          end
+        end
       end
 
       describe "expect(...).not_to have_received" do

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

@@ -0,0 +1,140 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    shared_examples_for "complains when given blocks" do
+      it "complains if a { } block is given" do
+        expect {
+          target.to receive_messages(:a => 1) { "implementation" }
+        }.to raise_error "Implementation blocks aren't supported with `receive_messages`"
+      end
+
+      it "complains if a do; end; block is given" do
+        expect {
+          target.to receive_messages(:a => 1) do
+            "implementation"
+          end
+        }.to raise_error "Implementation blocks aren't supported with `receive_messages`"
+      end
+    end
+
+    shared_examples_for "handles partially mocked objects correctly" do
+      let(:obj) { Struct.new(:a).new('original') }
+
+      it "resets partially mocked objects correctly" do
+        target.to receive_messages(:a => 1, :b => 2)
+
+        expect {
+          reset obj
+        }.to change { obj.a }.from(1).to("original")
+      end
+    end
+
+    describe "allow(...).to receive_messages(:a => 1, :b => 2)" do
+      let(:obj) { double "Object" }
+      let(:target) { allow(obj) }
+
+      it "allows the object to respond to multiple messages" do
+        allow(obj).to receive_messages(:a => 1, :b => 2)
+        expect(obj.a).to eq 1
+        expect(obj.b).to eq 2
+      end
+
+      it_behaves_like "complains when given blocks"
+      it_behaves_like "handles partially mocked objects correctly"
+    end
+
+    describe "allow_any_instance_of(...).to receive_messages(:a => 1, :b => 2)" do
+      let(:obj) { Object.new }
+      let(:target) { allow_any_instance_of(Object) }
+
+      it "allows the object to respond to multiple messages" do
+        allow_any_instance_of(Object).to receive_messages(:a => 1, :b => 2)
+        expect(obj.a).to eq 1
+        expect(obj.b).to eq 2
+      end
+
+      it_behaves_like "complains when given blocks"
+    end
+
+    describe "expect(...).to receive_messages(:a => 1, :b => 2)" do
+      let(:obj) { double "Object" }
+      let(:target) { expect(obj) }
+
+      let(:expectation_error) do
+        failure = nil
+        begin
+          RSpec::Mocks.space.verify_all
+        rescue RSpec::Mocks::MockExpectationError => error
+          failure = error
+        end
+        failure
+      end
+
+      it "sets up multiple expectations" do
+        expect(obj).to receive_messages(:a => 1, :b => 2)
+        obj.a
+        expect { RSpec::Mocks.space.verify_all }.to raise_error RSpec::Mocks::MockExpectationError
+      end
+
+      it 'fails with a sensible message' do
+        expect(obj).to receive_messages(:a => 1, :b => 2)
+        obj.b
+        expect(expectation_error.to_s).to eq %Q{(Double "Object").a(no args)\n    expected: 1 time with any arguments\n    received: 0 times}
+      end
+
+      it 'fails with the correct location' do
+        expect(obj).to receive_messages(:a => 1, :b => 2); line = __LINE__
+        expect(expectation_error.backtrace[0]).to match(/#{__FILE__}:#{line}/)
+      end
+
+      it_behaves_like "complains when given blocks"
+      it_behaves_like "handles partially mocked objects correctly"
+    end
+
+    describe "expect_any_instance_of(...).to receive_messages(:a => 1, :b => 2)" do
+      let(:obj) { Object.new }
+      let(:target) { expect_any_instance_of(Object) }
+
+      it "sets up multiple expectations" do
+        expect_any_instance_of(Object).to receive_messages(:a => 1, :b => 2)
+        obj.a
+        expect { RSpec::Mocks.space.verify_all }.to raise_error RSpec::Mocks::MockExpectationError
+      end
+
+      it_behaves_like "complains when given blocks"
+    end
+
+    describe "negative expectation failure" do
+      let(:obj) { Object.new }
+
+      example "allow(...).to_not receive_messages(:a => 1, :b => 2)" do
+        expect { allow(obj).to_not receive_messages(:a => 1, :b => 2) }.to(
+          raise_error "`allow(...).to_not receive_messages` is not supported "+
+                      "since it doesn't really make sense. What would it even mean?"
+        )
+      end
+
+      example "allow_any_instance_of(...).to_not receive_messages(:a => 1, :b => 2)" do
+        expect { allow_any_instance_of(obj).to_not receive_messages(:a => 1, :b => 2) }.to(
+          raise_error "`allow_any_instance_of(...).to_not receive_messages` is not supported "+
+                      "since it doesn't really make sense. What would it even mean?"
+        )
+      end
+
+      example "expect(...).to_not receive_messages(:a => 1, :b => 2)" do
+        expect { expect(obj).to_not receive_messages(:a => 1, :b => 2) }.to(
+          raise_error "`expect(...).to_not receive_messages` is not supported "+
+                      "since it doesn't really make sense. What would it even mean?"
+        )
+      end
+
+      example "expect_any_instance_of(...).to_not receive_messages(:a => 1, :b => 2)" do
+        expect { expect_any_instance_of(obj).to_not receive_messages(:a => 1, :b => 2) }.to(
+          raise_error "`expect_any_instance_of(...).to_not receive_messages` is not supported "+
+                      "since it doesn't really make sense. What would it even mean?"
+        )
+      end
+    end
+  end
+end