rspec-mocks 2.14.0.rc1 → 2.14.0

data/lib/rspec/mocks/proxy.rb

@@ -51,11 +51,6 @@ module RSpec
         meth_double.add_expectation @error_generator, @expectation_ordering, location, opts, &block
       end
 
-      # @private
-      def add_negative_message_expectation(location, method_name, &implementation)
-        method_double[method_name].add_negative_expectation @error_generator, @expectation_ordering, location, &implementation
-      end
-
       # @private
       def build_expectation(method_name)
         meth_double = method_double[method_name]

data/lib/rspec/mocks/proxy_for_nil.rb

@@ -28,7 +28,8 @@ module RSpec
       private
 
       def warn method_name
-        Kernel.warn("An expectation of :#{method_name} was set on nil. Called from #{caller[2]}. Use allow_message_expectations_on_nil to disable warnings.")
+        non_rspec_caller = caller.find { |line| !line.include?('lib/rspec/mocks') }
+        Kernel.warn("An expectation of :#{method_name} was set on nil. Called from #{non_rspec_caller}. Use allow_message_expectations_on_nil to disable warnings.")
       end
 
     end

data/lib/rspec/mocks/syntax.rb

@@ -12,20 +12,21 @@ module RSpec
 
         syntax_host.class_eval do
           def should_receive(message, opts={}, &block)
-            proxy = ::RSpec::Mocks.proxy_for(self)
-            proxy.add_message_expectation(opts[:expected_from] || caller(1)[0], message.to_sym, opts, &block)
+            opts[:expected_from] ||= caller(1)[0]
+            ::RSpec::Mocks.expect_message(self, message.to_sym, opts, &block)
           end
 
           def should_not_receive(message, &block)
-            proxy = ::RSpec::Mocks.proxy_for(self)
-            proxy.add_negative_message_expectation(caller(1)[0], message.to_sym, &block)
+            opts = {:expected_from => caller(1)[0]}
+            ::RSpec::Mocks.expect_message(self, message.to_sym, opts, &block).never
           end
 
           def stub(message_or_hash, opts={}, &block)
             if ::Hash === message_or_hash
               message_or_hash.each {|message, value| stub(message).and_return value }
             else
-              ::RSpec::Mocks.proxy_for(self).add_stub(caller(1)[0], message_or_hash.to_sym, opts, &block)
+              opts[:expected_from] = caller(1)[0]
+              ::RSpec::Mocks.allow_message(self, message_or_hash, opts, &block)
             end
           end
 
@@ -155,6 +156,15 @@ module RSpec
       # @api private
       # Determines where the methods like `should_receive`, and `stub` are added.
       def self.default_should_syntax_host
+        # JRuby 1.7.4 introduces a regression whereby `defined?(::BasicObject) => nil`
+        # yet `BasicObject` still exists and patching onto ::Object breaks things
+        # e.g. SimpleDelegator expectations won't work
+        #
+        # See: https://github.com/jruby/jruby/issues/814
+        if defined?(JRUBY_VERSION) && JRUBY_VERSION == '1.7.4' && RUBY_VERSION.to_f > 1.8
+          return ::BasicObject
+        end
+
         # On 1.8.7, Object.ancestors.last == Kernel but
         # things blow up if we include `RSpec::Mocks::Methods`
         # into Kernel...not sure why.

data/lib/rspec/mocks/test_double.rb

@@ -62,7 +62,7 @@ module RSpec
 
       # @private
       def __build_mock_proxy
-        Proxy.new(self, @name, @options)
+        Proxy.new(self, @name, @options || {})
       end
 
     private
@@ -110,7 +110,7 @@ module RSpec
 
       def assign_stubs(stubs)
         stubs.each_pair do |message, response|
-          stub(message).and_return(response)
+          Mocks.allow_message(self, message).and_return(response)
         end
       end
 

data/lib/rspec/mocks/version.rb

@@ -1,7 +1,7 @@
 module RSpec
   module Mocks
     module Version
-      STRING = '2.14.0.rc1'
+      STRING = '2.14.0'
     end
   end
 end

data/spec/rspec/mocks/any_instance_spec.rb

@@ -181,6 +181,26 @@ module RSpec
           end
         end
 
+        context 'with #and_call_original and competing #with' do
+          let(:klass) { Struct.new(:a_method) }
+
+          it 'can combine and_call_original, with, and_return' do
+            allow_any_instance_of(klass).to receive(:a_method).and_call_original
+            allow_any_instance_of(klass).to receive(:a_method).with(:arg).and_return('value')
+
+            expect(klass.new('org').a_method).to eq 'org'
+            expect(klass.new.a_method(:arg)).to  eq 'value'
+          end
+
+          it 'can combine and_call_original, with, and_return (old syntax)' do
+            klass.any_instance.stub(:a_method).and_call_original
+            klass.any_instance.stub(:a_method).with(:arg).and_return('value')
+
+            expect(klass.new('org').a_method).to eq 'org'
+            expect(klass.new.a_method(:arg)).to  eq 'value'
+          end
+        end
+
         context "with #and_raise" do
           it "stubs a method that doesn't exist" do
             klass.any_instance.stub(:foo).and_raise(CustomErrorForAnyInstanceSpec)
@@ -327,6 +347,12 @@ module RSpec
             RSpec::Mocks.space.verify_all
           end
         end
+
+        it "prevents confusing double-negative expressions involving `never`" do
+          expect {
+            klass.any_instance.should_not_receive(:not_expected).never
+          }.to raise_error(/trying to negate it again/)
+        end
       end
 
       context "with #should_receive" do

data/spec/rspec/mocks/block_return_value_spec.rb

@@ -23,6 +23,12 @@ describe "a double declaration with a block handed to:" do
       obj.stub(:foo) { 'bar' }
       expect(obj.foo).to eq('bar')
     end
+
+    it "does not complain if a lambda block and mismatched arguments are passed" do
+      obj = Object.new
+      obj.stub(:foo, &lambda { 'bar' })
+      expect(obj.foo(1, 2)).to eq('bar')
+    end
   end
 
   describe "with" do
@@ -31,6 +37,12 @@ describe "a double declaration with a block handed to:" do
       obj.stub(:foo).with('baz') { 'bar' }
       expect(obj.foo('baz')).to eq('bar')
     end
+
+    it "does not complain if a lambda block and mismatched arguments are passed" do
+      obj = Object.new
+      obj.stub(:foo).with(1, 2, &lambda { 'bar' })
+      expect(obj.foo(1, 2)).to eq('bar')
+    end
   end
 
   %w[once twice ordered and_return].each do |method|
@@ -40,6 +52,12 @@ describe "a double declaration with a block handed to:" do
         obj.stub(:foo).send(method) { 'bar' }
         expect(obj.foo).to eq('bar')
       end
+
+      it "does not complain if a lambda block and mismatched arguments are passed" do
+        obj = Object.new
+        obj.stub(:foo).send(method, &lambda { 'bar' })
+        expect(obj.foo(1, 2)).to eq('bar')
+      end
     end
   end
 

data/spec/rspec/mocks/combining_implementation_instructions_spec.rb

@@ -0,0 +1,205 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe "Combining implementation instructions" do
+      it 'can combine and_yield and and_return' do
+        dbl = double
+        dbl.stub(:foo).and_yield(5).and_return(3)
+
+        expect { |b|
+          expect(dbl.foo(&b)).to eq(3)
+        }.to yield_with_args(5)
+      end
+
+      describe "combining and_yield, a block implementation and and_return" do
+        def verify_combined_implementation
+          dbl = double
+          (yield dbl).and_yield(5).and_return(3)
+
+          expect { |b|
+            expect(dbl.foo(:arg, &b)).to eq(3)
+          }.to yield_with_args(5)
+
+          expect(@block_called).to be_true
+        end
+
+        it 'works when passing a block to `stub`' do
+          verify_combined_implementation do |dbl|
+            dbl.stub(:foo) { @block_called = true }
+          end
+        end
+
+        it 'works when passing a block to `with`' do
+          verify_combined_implementation do |dbl|
+            dbl.stub(:foo).with(:arg) { @block_called = true }
+          end
+        end
+
+        it 'works when passing a block to `exactly`' do
+          verify_combined_implementation do |dbl|
+            dbl.should_receive(:foo).exactly(:once) { @block_called = true }
+          end
+        end
+
+        it 'works when passing a block to `at_least`' do
+          verify_combined_implementation do |dbl|
+            dbl.should_receive(:foo).at_least(:once) { @block_called = true }
+          end
+        end
+
+        it 'works when passing a block to `at_most`' do
+          verify_combined_implementation do |dbl|
+            dbl.should_receive(:foo).at_most(:once) { @block_called = true }
+          end
+        end
+
+        it 'works when passing a block to `times`' do
+          verify_combined_implementation do |dbl|
+            dbl.should_receive(:foo).exactly(1).times { @block_called = true }
+          end
+        end
+
+        it 'works when passing a block to `any_number_of_times`' do
+          verify_combined_implementation do |dbl|
+            dbl.should_receive(:foo).any_number_of_times { @block_called = true }
+          end
+        end
+
+        it 'works when passing a block to `once`' do
+          verify_combined_implementation do |dbl|
+            dbl.should_receive(:foo).once { @block_called = true }
+          end
+        end
+
+        it 'works when passing a block to `twice`' do
+          the_double = nil
+
+          verify_combined_implementation do |dbl|
+            the_double = dbl
+            dbl.should_receive(:foo).twice { @block_called = true }
+          end
+
+          the_double.foo { |a| } # to ensure it is called twice
+        end
+
+        it 'works when passing a block to `ordered`' do
+          verify_combined_implementation do |dbl|
+            dbl.should_receive(:foo).ordered { @block_called = true }
+          end
+        end
+      end
+
+      it 'can combine and_yield and and_return with a block' do
+        dbl = double
+        dbl.stub(:foo).and_yield(5).and_return { :return }
+
+        expect { |b|
+          expect(dbl.foo(&b)).to eq(:return)
+        }.to yield_with_args(5)
+      end
+
+      it 'can combine and_yield and and_raise' do
+        dbl = double
+        dbl.stub(:foo).and_yield(5).and_raise("boom")
+
+        expect { |b|
+          expect { dbl.foo(&b) }.to raise_error("boom")
+        }.to yield_with_args(5)
+      end
+
+      it 'can combine and_yield, a block implementation and and_raise' do
+        dbl = double
+        block_called = false
+        dbl.stub(:foo) { block_called = true }.and_yield(5).and_raise("boom")
+
+        expect { |b|
+          expect { dbl.foo(&b) }.to raise_error("boom")
+        }.to yield_with_args(5)
+
+        expect(block_called).to be_true
+      end
+
+      it 'can combine and_yield and and_throw' do
+        dbl = double
+        dbl.stub(:foo).and_yield(5).and_throw(:bar)
+
+        expect { |b|
+          expect { dbl.foo(&b) }.to throw_symbol(:bar)
+        }.to yield_with_args(5)
+      end
+
+      it 'can combine and_yield, a block implementation and and_throw' do
+        dbl = double
+        block_called = false
+        dbl.stub(:foo) { block_called = true }.and_yield(5).and_throw(:bar)
+
+        expect { |b|
+          expect { dbl.foo(&b) }.to throw_symbol(:bar)
+        }.to yield_with_args(5)
+
+        expect(block_called).to be_true
+      end
+
+      it 'returns `nil` from all terminal actions to discourage further configuration' do
+        expect(double.stub(:foo).and_return(1)).to be_nil
+        expect(double.stub(:foo).and_raise("boom")).to be_nil
+        expect(double.stub(:foo).and_throw(:foo)).to be_nil
+      end
+
+      it 'allows the terminal action to be overriden' do
+        dbl = double
+        stubbed_double = dbl.stub(:foo)
+
+        stubbed_double.and_return(1)
+        expect(dbl.foo).to eq(1)
+
+        stubbed_double.and_return(3)
+        expect(dbl.foo).to eq(3)
+
+        stubbed_double.and_raise("boom")
+        expect { dbl.foo }.to raise_error("boom")
+
+        stubbed_double.and_throw(:bar)
+        expect { dbl.foo }.to throw_symbol(:bar)
+      end
+
+      it 'allows the inner implementation block to be overriden' do
+        dbl = double
+        stubbed_double = dbl.stub(:foo)
+
+        stubbed_double.with(:arg) { :with_block }
+        expect(dbl.foo(:arg)).to eq(:with_block)
+
+        stubbed_double.at_least(:once) { :at_least_block }
+        expect(dbl.foo(:arg)).to eq(:at_least_block)
+      end
+
+      it 'can combine and_call_original, with, and_return' do
+        obj = Struct.new(:value).new('original')
+        obj.stub(:value).and_call_original
+        obj.stub(:value).with(:arg).and_return('value')
+        expect(obj.value).to eq 'original'
+        expect(obj.value(:arg)).to eq 'value'
+      end
+
+      it 'raises an error if `and_call_original` is followed by any other instructions' do
+        dbl = [1, 2, 3]
+        stubbed = dbl.stub(:size)
+        stubbed.and_call_original
+
+        msg_fragment = /cannot be modified further/
+
+        expect { stubbed.and_yield }.to raise_error(msg_fragment)
+        expect { stubbed.and_return(1) }.to raise_error(msg_fragment)
+        expect { stubbed.and_raise("a") }.to raise_error(msg_fragment)
+        expect { stubbed.and_throw(:bar) }.to raise_error(msg_fragment)
+
+        expect { stubbed.once { } }.to raise_error(msg_fragment)
+
+        expect(dbl.size).to eq(3)
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+describe Marshal, 'extensions' do
+  # An object that raises when code attempts to dup it.
+  #
+  # Because we manipulate the internals of RSpec::Mocks.space below, we need
+  # an object that simply blows up when #dup is called without using any
+  # partial mocking or stubbing from rspec-mocks itself.
+  class UndupableObject
+    def dup
+      raise NotImplementedError
+    end
+  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")
+
+        serialized = Marshal.dump(obj)
+        expect(Marshal.load(serialized)).to be_an(obj.class)
+      end
+
+      it 'does not duplicate other objects before serialization' do
+        obj = UndupableObject.new
+
+        serialized = Marshal.dump(obj)
+        expect(Marshal.load(serialized)).to be_an(UndupableObject)
+      end
+
+      it 'does not duplicate nil before serialization' do
+        serialized = Marshal.dump(nil)
+        expect(Marshal.load(serialized)).to be_nil
+      end
+    end
+  end
+end

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

@@ -136,6 +136,16 @@ module RSpec
             receiver.foo(:a)
           }.to raise_error(/expected: 0 times.*received: 1 time/m)
         end
+
+        it 'prevents confusing double-negative expressions involving `never`' do
+          expect {
+            wrapped.not_to receive(:foo).never
+          }.to raise_error(/trying to negate it again/)
+
+          expect {
+            wrapped.to_not receive(:foo).never
+          }.to raise_error(/trying to negate it again/)
+        end
       end
 
       describe "allow(...).to receive" do