rspec-mocks 2.99.4 → 3.0.0.beta1

data/spec/rspec/mocks/argument_expectation_spec.rb

@@ -9,23 +9,23 @@ module RSpec
       it "considers an object that responds to #matches? and #failure_message_for_should to be a matcher" do
         obj.stub(:matches?)
         obj.stub(:failure_message_for_should)
-        expect(argument_expectation.send(:is_matcher?, obj)).to be true
+        expect(argument_expectation.send(:is_matcher?, obj)).to be_truthy
       end
 
       it "considers an object that responds to #matches? and #failure_message to be a matcher for backward compatibility" do
         obj.stub(:matches?)
         obj.stub(:failure_message)
-        expect(argument_expectation.send(:is_matcher?, obj)).to be true
+        expect(argument_expectation.send(:is_matcher?, obj)).to be_truthy
       end
 
       it "does NOT consider an object that only responds to #matches? to be a matcher" do
         obj.stub(:matches?)
-        expect(argument_expectation.send(:is_matcher?, obj)).to be false
+        expect(argument_expectation.send(:is_matcher?, obj)).to be_falsey
       end
 
       it "does not consider a null object to be a matcher" do
         obj.as_null_object
-        expect(argument_expectation.send(:is_matcher?, obj)).to be false
+        expect(argument_expectation.send(:is_matcher?, obj)).to be_falsey
       end
     end
   end

data/spec/rspec/mocks/arity_calculator_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    describe ArityCalculator do
+      describe '#verify!' do
+        subject { described_class.new(test_method) }
+
+        def within_range?(arity)
+          subject.within_range?(arity)
+        end
+
+        def description
+          subject.range_description
+        end
+
+        describe 'with a method with arguments' do
+          def arity_two(x, y); end
+
+          let(:test_method) { method(:arity_two) }
+
+          it 'covers only the exact arity' do
+            expect(within_range?(1)).to eq(false)
+            expect(within_range?(2)).to eq(true)
+            expect(within_range?(3)).to eq(false)
+          end
+
+          it 'is described precisely' do
+            expect(description).to eq("2")
+          end
+        end
+
+        describe 'a method with splat arguments' do
+          def arity_splat(_, *); end
+
+          let(:test_method) { method(:arity_splat) }
+
+          it 'covers a range from the lower bound upwards' do
+            expect(within_range?(0)).to eq(false)
+            expect(within_range?(1)).to eq(true)
+            expect(within_range?(2)).to eq(true)
+            expect(within_range?(3)).to eq(true)
+          end
+
+          it 'is described with no upper bound' do
+            expect(description).to eq("1 or more")
+          end
+        end
+
+        describe 'a method with optional arguments' do
+          def arity_optional(x, y, z = 1); end
+
+          let(:test_method) { method(:arity_optional) }
+
+          it 'covers a range from min to max possible arguments' do
+            expect(within_range?(1)).to eq(false)
+            expect(within_range?(2)).to eq(true)
+            expect(within_range?(3)).to eq(true)
+
+            if ArityCalculator.supports_optional_and_splat_args?
+              expect(within_range?(4)).to eq(false)
+            else
+              expect(within_range?(4)).to eq(true)
+            end
+          end
+
+          if ArityCalculator.supports_optional_and_splat_args?
+            it 'is described as a range' do
+              expect(description).to eq("2 to 3")
+            end
+          else
+            it 'is described with no upper bound' do
+              expect(description).to eq("2 or more")
+            end
+          end
+        end
+
+        describe 'a method with a block' do
+          def arity_block(_, &block); end
+
+          let(:test_method) { method(:arity_block) }
+
+          it 'does not count the block as a parameter' do
+            expect(within_range?(1)).to eq(true)
+            expect(within_range?(2)).to eq(false)
+          end
+
+          it 'is described precisely' do
+            expect(description).to eq("1")
+          end
+        end
+      end
+    end
+  end
+end

data/spec/rspec/mocks/array_including_matcher_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+module RSpec
+  module Mocks
+    module ArgumentMatchers
+      describe ArrayIncludingMatcher do
+        it "describes itself properly" do
+          expect(ArrayIncludingMatcher.new([1, 2, 3]).description).to eq "array_including(1,2,3)"
+        end
+
+        context "passing" do
+          it "matches the same array" do
+            expect(array_including(1, 2, 3)).to eq([1, 2, 3])
+          end
+
+          it "matches the same array,  specified without square brackets" do
+            expect(array_including(1, 2, 3)).to eq([1, 2, 3])
+          end
+
+          it "matches the same array,  which includes nested arrays" do
+            expect(array_including([1, 2], 3, 4)).to eq([[1, 2], 3, 4])
+          end
+
+          it "works with duplicates in expected" do
+            expect(array_including(1, 1, 2, 3)).to eq([1, 2, 3])
+          end
+
+          it "works with duplicates in actual" do
+            expect(array_including(1, 2, 3)).to eq([1, 1, 2, 3])
+          end
+        end
+
+        context "failing" do
+          it "fails when not all the entries in the expected are present" do
+            expect(array_including(1,2,3,4,5)).not_to eq([1,2])
+          end
+        end
+      end
+    end
+  end
+end

data/spec/rspec/mocks/at_least_spec.rb

@@ -98,38 +98,10 @@ module RSpec
       end
 
       context "when sent with 0" do
-        before { RSpec.stub(:deprecate) }
-
-        it "outputs a deprecation warning" do
-          expect(RSpec).to receive(:deprecate).with("at_least\(0\) with should_receive", :replacement => "stub")
-          expect(@double).to receive(:do_something).at_least(0).times
-        end
-
-        it "passes with no return if called once" do
-          @double.should_receive(:do_something).at_least(0).times
-          @double.do_something
-        end
-
-        it "passes with return block if called once" do
-          @double.should_receive(:do_something).at_least(0).times { true }
-          @double.do_something
-        end
-
-        it "passes with and_return if called once" do
-          @double.should_receive(:do_something).at_least(0).times.and_return true
-          @double.do_something
-        end
-
-        it "passes with no return if never called" do
-          @double.should_receive(:do_something).at_least(0).times
-        end
-
-        it "passes with return block if never called" do
-          @double.should_receive(:do_something).at_least(0).times { true }
-        end
-
-        it "passes with and_return if never called" do
-          @double.should_receive(:do_something).at_least(0).times.and_return true
+        it "outputs a removal message" do
+          expect {
+            expect(@double).to receive(:do_something).at_least(0).times
+          }.to raise_error(/has been removed/)
         end
       end
 

data/spec/rspec/mocks/block_return_value_spec.rb

@@ -1,17 +1,6 @@
 require "spec_helper"
 
 describe "a double declaration with a block handed to:" do
-  # The "receives a block" part is important: 1.8.7 has a bug that reports the
-  # wrong arity when a block receives a block.
-  it 'forwards all given args to the block, even when it receives a block', :unless => RUBY_VERSION.to_s == '1.8.6' do
-    obj = Object.new
-    yielded_args = []
-    eval("obj.stub(:foo) { |*args, &bl| yielded_args << args }")
-    obj.foo(1, 2, 3)
-
-    expect(yielded_args).to eq([[1, 2, 3]])
-  end
-
   describe "should_receive" do
     it "returns the value of executing the block" do
       obj = Object.new
@@ -34,23 +23,6 @@ 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
-      RSpec.stub :deprecate
-      obj = Object.new
-      obj.stub(:foo, &lambda { 'bar' })
-      expect(obj.foo(1, 2)).to eq('bar')
-    end
-
-    it 'warns of deprection if argument counts dont match' do
-      expect(RSpec).to receive(:deprecate) do |message, opts|
-        expect(message).to eq "stubbing implementations with mismatched arity"
-        expect(opts[:call_site]).to match %r%/spec/rspec/mocks/block_return_value_spec.rb%
-      end
-      obj = Object.new
-      obj.stub(:foo, &lambda { 'bar' })
-      expect(obj.foo(1, 2)).to eq('bar')
-    end
   end
 
   describe "with" do
@@ -60,123 +32,20 @@ describe "a double declaration with a block handed to:" do
       expect(obj.foo('baz')).to eq('bar')
     end
 
-    it "does not complain if a lambda block and mismatched arguments are passed" do
-      RSpec.stub :deprecate
-      obj = Object.new
-      obj.stub(:foo).with(1, 2, &lambda { 'bar' })
-      expect(obj.foo(1, 2)).to eq('bar')
-    end
-
-    it 'warns of deprection if argument counts dont match' do
-      expect(RSpec).to receive(:deprecate) do |message, opts|
-        expect(message).to eq "stubbing implementations with mismatched arity"
-        expect(opts[:call_site]).to match %r%/spec/rspec/mocks/block_return_value_spec.rb%
-      end
-      obj = Object.new
-      obj.stub(:foo).with(1, 2, &lambda { 'bar' })
-      expect(obj.foo(1, 2)).to eq('bar')
-    end
-
-    it 'warns of deprecation when provided block but no arguments' do
-      expect(RSpec).to receive(:deprecate) do |message, opts|
-        expect(message).to match(/Using the return value of a `with` block/)
-      end
-      obj = Object.new
-      obj.stub(:foo).with {|x| 'baz' }.and_return('bar')
-      expect(obj.foo(1)).to eq('bar')
-    end
-
-    it 'includes callsite in deprecation of provided block but no arguments' do
+    it "returns the value of executing the block with given argument" do
       obj = Object.new
-      expect_deprecation_with_call_site __FILE__, __LINE__ + 1
-      obj.stub(:foo).with {|x| 'baz' }.and_return('bar')
-      expect(obj.foo(1)).to eq('bar')
+      obj.stub(:foo).with('baz') {|x| 'bar' + x }
+      expect(obj.foo('baz')).to eq('barbaz')
     end
   end
 
-  %w[once twice ordered].each do |method|
+  %w[once twice ordered and_return].each do |method|
     describe method do
       it "returns the value of executing the block" do
         obj = Object.new
         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
-        RSpec.stub :deprecate
-        obj = Object.new
-        obj.stub(:foo).send(method, &lambda { 'bar' })
-        expect(obj.foo(1, 2)).to eq('bar')
-      end
-
-      it 'warns of deprection if argument counts dont match' do
-        expect(RSpec).to receive(:deprecate) do |message, opts|
-          expect(message).to eq "stubbing implementations with mismatched arity"
-          expect(opts[:call_site]).to match %r%/spec/rspec/mocks/block_return_value_spec.rb%
-        end
-        obj = Object.new
-        obj.stub(:foo).send(method, &lambda { 'bar' })
-        expect(obj.foo(1, 2)).to eq('bar')
-      end
-    end
-  end
-
-  describe 'and_return' do
-    before do
-      allow_deprecation
-    end
-
-    it "returns the value of executing the block" do
-      obj = Object.new
-      obj.stub(:foo).and_return { '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).and_return(&lambda { 'bar' })
-      expect(obj.foo(1, 2)).to eq('bar')
-    end
-
-    it 'warns of deprecation of `and_return { value }`' do
-      expect_deprecation_with_call_site(__FILE__, __LINE__ + 3, '`and_return { value }`')
-
-      obj = Object.new
-      obj.stub(:foo).and_return { 'bar' }
-      expect(obj.foo(1, 2)).to eq('bar')
-    end
-
-    it 'warns of deprection if argument counts dont match' do
-      warned = false
-
-      expect(RSpec).to receive(:deprecate).at_least(1) do |message, opts|
-        next unless message == "stubbing implementations with mismatched arity"
-        expect(opts[:call_site]).to match %r%/spec/rspec/mocks/block_return_value_spec.rb%
-        warned = true
-      end
-
-      obj = Object.new
-      obj.stub(:foo).and_return(&lambda { 'bar' })
-      expect(obj.foo(1, 2)).to eq('bar')
-
-      expect(warned).to be true
-    end
-  end
-
-  describe 'any_number_of_times' do
-    before do
-      RSpec.stub(:deprecate)
-    end
-
-    it "warns about deprecation" do
-      expect(RSpec).to receive(:deprecate).with("any_number_of_times", :replacement => "stub")
-      Object.new.stub(:foo).any_number_of_times { 'bar' }
-    end
-
-    it "returns the value of executing the block" do
-      obj = Object.new
-      obj.stub(:foo).any_number_of_times { 'bar' }
-      expect(obj.foo).to eq('bar')
     end
   end
 

data/spec/rspec/mocks/combining_implementation_instructions_spec.rb

@@ -21,7 +21,7 @@ module RSpec
             expect(dbl.foo(:arg, &b)).to eq(3)
           }.to yield_with_args(5)
 
-          expect(@block_called).to be true
+          expect(@block_called).to be_truthy
         end
 
         it 'works when passing a block to `stub`' do
@@ -60,12 +60,6 @@ module RSpec
           end
         end
 
-        it 'works when passing a block to `any_number_of_times`', :silence_warnings 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 }
@@ -91,8 +85,6 @@ module RSpec
       end
 
       it 'can combine and_yield and and_return with a block' do
-        allow_deprecation
-
         dbl = double
         dbl.stub(:foo).and_yield(5).and_return { :return }
 
@@ -119,7 +111,7 @@ module RSpec
           expect { dbl.foo(&b) }.to raise_error("boom")
         }.to yield_with_args(5)
 
-        expect(block_called).to be true
+        expect(block_called).to be_truthy
       end
 
       it 'can combine and_yield and and_throw' do
@@ -140,7 +132,7 @@ module RSpec
           expect { dbl.foo(&b) }.to throw_symbol(:bar)
         }.to yield_with_args(5)
 
-        expect(block_called).to be true
+        expect(block_called).to be_truthy
       end
 
       it 'returns `nil` from all terminal actions to discourage further configuration' do
@@ -167,6 +159,7 @@ module RSpec
       end
 
       it 'allows the inner implementation block to be overriden' do
+        allow(RSpec).to receive(:warning)
         dbl = double
         stubbed_double = dbl.stub(:foo)
 
@@ -177,6 +170,11 @@ module RSpec
         expect(dbl.foo(:arg)).to eq(:at_least_block)
       end
 
+      it 'warns when the inner implementation block is overriden' do
+        expect(RSpec).to receive(:warning).with(/overriding a previous implementation/)
+        double.stub(:foo).with(:arg) { :with_block }.at_least(:once) { :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
@@ -186,6 +184,7 @@ module RSpec
       end
 
       it 'raises an error if `and_call_original` is followed by any other instructions' do
+        allow(RSpec).to receive(:warning)
         dbl = [1, 2, 3]
         stubbed = dbl.stub(:size)
         stubbed.and_call_original