rspec-mocks 3.0.0.beta2 → 3.0.0.rc1

data/spec/rspec/mocks/method_signature_verifier_spec.rb

@@ -1,272 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Mocks
-    describe MethodSignatureVerifier do
-      describe '#verify!' do
-        let(:signature) { MethodSignature.new(test_method) }
-
-        def valid_non_kw_args?(arity)
-          described_class.new(signature, [nil] * arity).valid?
-        end
-
-        def valid?(*args)
-          described_class.new(signature, args).valid?
-        end
-
-        def error_description
-          described_class.new(signature, []).error_message[/Expected (.*),/, 1]
-        end
-
-        def error_for(*args)
-          described_class.new(signature, args).error_message
-        end
-
-        def signature_description
-          signature.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(valid_non_kw_args?(1)).to eq(false)
-            expect(valid_non_kw_args?(2)).to eq(true)
-            expect(valid_non_kw_args?(3)).to eq(false)
-          end
-
-          it 'does not treat a last-arg hash as kw args' do
-            expect(valid?(1, {})).to eq(true)
-          end
-
-          it 'describes the arity precisely' do
-            expect(error_description).to eq("2")
-          end
-
-          it 'mentions only the arity in the description' do
-            expect(signature_description).to eq("arity of 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(valid_non_kw_args?(0)).to eq(false)
-            expect(valid_non_kw_args?(1)).to eq(true)
-            expect(valid_non_kw_args?(2)).to eq(true)
-            expect(valid_non_kw_args?(3)).to eq(true)
-          end
-
-          it 'describes the arity with no upper bound' do
-            expect(error_description).to eq("1 or more")
-          end
-
-          it 'mentions only the arity in the description' do
-            expect(signature_description).to eq("arity of 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(valid_non_kw_args?(1)).to eq(false)
-            expect(valid_non_kw_args?(2)).to eq(true)
-            expect(valid_non_kw_args?(3)).to eq(true)
-
-            if optional_and_splat_args_supported?
-              expect(valid_non_kw_args?(4)).to eq(false)
-            else
-              expect(valid_non_kw_args?(4)).to eq(true)
-            end
-          end
-
-          if optional_and_splat_args_supported?
-            it 'describes the arity as a range' do
-              expect(error_description).to eq("2 to 3")
-            end
-          else
-            it 'describes the arity with no upper bound' do
-              expect(error_description).to eq("2 or more")
-            end
-          end
-        end
-
-        if kw_args_supported?
-          describe 'a method with optional keyword arguments' do
-            eval <<-RUBY
-              def arity_kw(x, y:1, z:2); end
-            RUBY
-
-            let(:test_method) { method(:arity_kw) }
-
-            it 'does not require any of the arguments' do
-              expect(valid?(nil)).to eq(true)
-              expect(valid?(nil, nil)).to eq(false)
-            end
-
-            it 'does not allow an invalid keyword arguments' do
-              expect(valid?(nil, :a => 1)).to eq(false)
-            end
-
-            it 'mentions the invalid keyword args in the error' do
-              expect(error_for(nil, :a => 0, :b => 1)).to \
-                eq("Invalid keyword arguments provided: a, b")
-            end
-
-            it 'describes invalid arity precisely' do
-              expect(error_for()).to \
-                eq("Wrong number of arguments. Expected 1, got 0.")
-            end
-
-            it 'does not blow up when given a BasicObject as the last arg' do
-              expect(valid?(BasicObject.new)).to eq(true)
-            end
-
-            it 'does not mutate the provided args array' do
-              args = [nil, { :y => 1 }]
-              described_class.new(signature, args).valid?
-              expect(args).to eq([nil, { :y => 1 }])
-            end
-
-            it 'mentions the arity and optional kw args in the description' do
-              expect(signature_description).to eq("arity of 1 and optional keyword args (:y, :z)")
-            end
-          end
-        end
-
-        if required_kw_args_supported?
-          describe 'a method with required keyword arguments' do
-            eval <<-RUBY
-              def arity_required_kw(x, y:, z:, a: 'default'); end
-            RUBY
-
-            let(:test_method) { method(:arity_required_kw) }
-
-            it 'returns false unless all required keywords args are present' do
-              expect(valid?(nil, :a => 0, :y => 1, :z => 2)).to eq(true)
-              expect(valid?(nil, :a => 0, :y => 1)).to eq(false)
-              expect(valid?(nil, nil, :a => 0, :y => 1, :z => 2)).to eq(false)
-              expect(valid?(nil, nil)).to eq(false)
-            end
-
-            it 'mentions the missing required keyword args in the error' do
-              expect(error_for(nil, :a => 0)).to \
-                eq("Missing required keyword arguments: y, z")
-            end
-
-            it 'is described precisely when arity is wrong' do
-              expect(error_for(nil, nil, :z => 0, :y => 1)).to \
-                eq("Wrong number of arguments. Expected 1, got 2.")
-            end
-
-            it 'mentions the arity, optional kw args and required kw args in the description' do
-              expect(signature_description).to \
-                eq("arity of 1 and optional keyword args (:a) and required keyword args (:y, :z)")
-            end
-          end
-
-          describe 'a method with required keyword arguments and a splat' do
-            eval <<-RUBY
-              def arity_required_kw_splat(w, *x, y:, z:, a: 'default'); end
-            RUBY
-
-            let(:test_method) { method(:arity_required_kw_splat) }
-
-            it 'returns false unless all required keywords args are present' do
-              expect(valid?(nil, :a => 0, :y => 1, :z => 2)).to eq(true)
-              expect(valid?(nil, :a => 0, :y => 1)).to eq(false)
-              expect(valid?(nil, nil, :a => 0, :y => 1, :z => 2)).to eq(true)
-              expect(valid?(nil, nil, nil)).to eq(false)
-              expect(valid?).to eq(false)
-            end
-
-            it 'mentions missing required keyword args in the error' do
-              expect(error_for(nil, :y => 1)).to \
-                eq("Missing required keyword arguments: z")
-            end
-
-            it 'mentions the arity, optional kw args and required kw args in the description' do
-              expect(signature_description).to \
-                eq("arity of 1 or more and optional keyword args (:a) and required keyword args (:y, :z)")
-            end
-          end
-
-          describe 'a method with required keyword arguments and a keyword arg splat' do
-            eval <<-RUBY
-              def arity_kw_arg_splat(x:, **rest); end
-            RUBY
-
-            let(:test_method) { method(:arity_kw_arg_splat) }
-
-            it 'allows extra undeclared keyword args' do
-              expect(valid?(:x => 1)).to eq(true)
-              expect(valid?(:x => 1, :y => 2)).to eq(true)
-            end
-
-            it 'mentions missing required keyword args in the error' do
-              expect(error_for(:y => 1)).to \
-                eq("Missing required keyword arguments: x")
-            end
-
-            it 'mentions the required kw args and keyword splat in the description' do
-              expect(signature_description).to \
-                eq("required keyword args (:x) and any additional keyword args")
-            end
-          end
-
-          describe 'a method with a required arg and a keyword arg splat' do
-            eval <<-RUBY
-              def arity_kw_arg_splat(x, **rest); end
-            RUBY
-
-            let(:test_method) { method(:arity_kw_arg_splat) }
-
-            it 'allows a single arg and any number of keyword args' do
-              expect(valid?(nil)).to eq(true)
-              expect(valid?(nil, :x => 1)).to eq(true)
-              expect(valid?(nil, :x => 1, :y => 2)).to eq(true)
-              expect(valid?(:x => 1)).to eq(true)
-
-              expect(valid?).to eq(false)
-              expect(valid?(nil, nil)).to eq(false)
-              expect(valid?(nil, nil, :x => 1)).to eq(false)
-            end
-
-            it 'describes the arity precisely' do
-              expect(error_for()).to \
-                eq("Wrong number of arguments. Expected 1, got 0.")
-            end
-
-            it 'mentions the required kw args and keyword splat in the description' do
-              expect(signature_description).to \
-                eq("arity of 1 and any additional keyword args")
-            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(valid_non_kw_args?(1)).to eq(true)
-            expect(valid_non_kw_args?(2)).to eq(false)
-          end
-
-          it 'describes the arity precisely' do
-            expect(error_description).to eq("1")
-          end
-        end
-      end
-    end
-  end
-end

data/spec/rspec/mocks/methods_spec.rb

@@ -1,26 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Mocks
-    describe "Methods added to every object" do
-      include_context "with syntax", :expect
-
-      def added_methods
-        host = Class.new
-        orig_instance_methods = host.instance_methods
-        Syntax.enable_should(host)
-        (host.instance_methods - orig_instance_methods).map(&:to_sym)
-      end
-
-      it 'limits the number of methods that get added to all objects' do
-        # If really necessary, you can add to this list, but long term,
-        # we are hoping to cut down on the number of methods added to all objects
-        expect(added_methods).to match_array([
-          :as_null_object, :null_object?,
-          :received_message?, :should_not_receive, :should_receive,
-          :stub, :stub_chain, :unstub
-        ])
-      end
-    end
-  end
-end

data/spec/rspec/mocks/mock_expectation_error_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Mocks
-    describe 'MockExpectationError' do
-
-      class Foo
-        def self.foo
-          bar
-        rescue StandardError
-        end
-      end
-
-      it 'is not caught by StandardError rescue blocks' do
-        expect(Foo).not_to receive(:bar)
-        expect {
-          Foo.foo
-        }.to raise_error(RSpec::Mocks::MockExpectationError)
-      end
-    end
-  end
-end

data/spec/rspec/mocks/mock_ordering_spec.rb

@@ -1,114 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Mocks
-
-    describe "ordering" do
-      before { @double = double("test double") }
-      after  { reset @double }
-
-      it "passes when messages are received in order" do
-        @double.should_receive(:one).ordered
-        @double.should_receive(:two).ordered
-        @double.should_receive(:three).ordered
-        @double.one
-        @double.two
-        @double.three
-      end
-
-      it "passes when messages are received in order" do
-        @double.stub(:something)
-        @double.should_receive(:one).ordered
-        @double.should_receive(:two).ordered
-        @double.should_receive(:three).at_least(:once).ordered
-        @double.one
-        @double.two
-        @double.three
-        @double.three
-      end
-
-      it "passes when messages are received in order across objects" do
-        a = double("a")
-        b = double("b")
-        a.should_receive(:one).ordered
-        b.should_receive(:two).ordered
-        a.should_receive(:three).ordered
-        a.one
-        b.two
-        a.three
-      end
-
-      it "fails when messages are received out of order (2nd message 1st)" do
-        @double.should_receive(:one).ordered
-        @double.should_receive(:two).ordered
-        expect {
-          @double.two
-        }.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" received :two out of order")
-      end
-
-      it "fails when messages are received out of order (3rd message 1st)" do
-        @double.should_receive(:one).ordered
-        @double.should_receive(:two).ordered
-        @double.should_receive(:three).ordered
-        @double.one
-        expect {
-          @double.three
-        }.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" received :three out of order")
-      end
-
-      it "fails when messages are received out of order (3rd message 2nd)" do
-        @double.should_receive(:one).ordered
-        @double.should_receive(:two).ordered
-        @double.should_receive(:three).ordered
-        @double.one
-        expect {
-          @double.three
-        }.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" received :three out of order")
-      end
-
-      it "fails when messages are out of order across objects" do
-        a = double("test double")
-        b = double("another test double")
-        a.should_receive(:one).ordered
-        b.should_receive(:two).ordered
-        a.should_receive(:three).ordered
-        a.one
-        expect {
-          a.three
-        }.to raise_error(RSpec::Mocks::MockExpectationError, "Double \"test double\" received :three out of order")
-        reset a
-        reset b
-      end
-
-      it "ignores order of non ordered messages" do
-        @double.should_receive(:ignored_0)
-        @double.should_receive(:ordered_1).ordered
-        @double.should_receive(:ignored_1)
-        @double.should_receive(:ordered_2).ordered
-        @double.should_receive(:ignored_2)
-        @double.should_receive(:ignored_3)
-        @double.should_receive(:ordered_3).ordered
-        @double.should_receive(:ignored_4)
-        @double.ignored_3
-        @double.ordered_1
-        @double.ignored_0
-        @double.ordered_2
-        @double.ignored_4
-        @double.ignored_2
-        @double.ordered_3
-        @double.ignored_1
-        verify @double
-      end
-
-      it "supports duplicate messages" do
-        @double.should_receive(:a).ordered
-        @double.should_receive(:b).ordered
-        @double.should_receive(:a).ordered
-
-        @double.a
-        @double.b
-        @double.a
-      end
-    end
-  end
-end

data/spec/rspec/mocks/multiple_return_value_spec.rb

@@ -1,132 +0,0 @@
-require 'spec_helper'
-
-module RSpec
-  module Mocks
-    describe "a double stubbed with multiple return values" do
-      let(:a_double) { double }
-
-      before do
-        a_double.stub(:foo).and_return(:val_1, nil)
-      end
-
-      it 'can still set a message expectation with a single return value' do
-        a_double.should_receive(:foo).once.and_return(:val_1)
-        expect(a_double.foo).to eq(:val_1)
-      end
-    end
-
-    describe "a message expectation with multiple return values and no specified count" do
-      before(:each) do
-        @double = double
-        @return_values = [1,2,3]
-        @double.should_receive(:do_something).and_return(@return_values[0],@return_values[1],@return_values[2])
-      end
-
-      it "returns values in order" do
-        expect(@double.do_something).to eq @return_values[0]
-        expect(@double.do_something).to eq @return_values[1]
-        expect(@double.do_something).to eq @return_values[2]
-        verify @double
-      end
-
-      it "falls back to a previously stubbed value" do
-        @double.stub :do_something => :stub_result
-        expect(@double.do_something).to eq @return_values[0]
-        expect(@double.do_something).to eq @return_values[1]
-        expect(@double.do_something).to eq @return_values[2]
-        expect(@double.do_something).to eq :stub_result
-      end
-
-      it "fails when there are too few calls (if there is no stub)" do
-        @double.do_something
-        @double.do_something
-        expect { verify @double }.to raise_error
-      end
-
-      it "fails when there are too many calls (if there is no stub)" do
-        @double.do_something
-        @double.do_something
-        @double.do_something
-        @double.do_something
-        expect { verify @double }.to raise_error
-      end
-    end
-
-    describe "a message expectation with multiple return values with a specified count equal to the number of values" do
-      before(:each) do
-        @double = double
-        @return_values = [1,2,3]
-        @double.should_receive(:do_something).exactly(3).times.and_return(@return_values[0], @return_values[1], @return_values[2])
-      end
-
-      it "returns values in order to consecutive calls" do
-        expect(@double.do_something).to eq @return_values[0]
-        expect(@double.do_something).to eq @return_values[1]
-        expect(@double.do_something).to eq @return_values[2]
-        verify @double
-      end
-    end
-
-    describe "a message expectation with multiple return values specifying at_least less than the number of values" do
-      before(:each) do
-        @double = double
-        @double.should_receive(:do_something).at_least(:twice).with(no_args).and_return(11, 22)
-      end
-
-      it "uses the last return value for subsequent calls" do
-        expect(@double.do_something).to equal(11)
-        expect(@double.do_something).to equal(22)
-        expect(@double.do_something).to equal(22)
-        verify @double
-      end
-
-      it "fails when called less than the specified number" do
-        expect(@double.do_something).to equal(11)
-        expect { verify @double }.to raise_error(RSpec::Mocks::MockExpectationError)
-      end
-
-      context "when method is stubbed too" do
-        before { @double.stub(:do_something).and_return :stub_result }
-
-        it "uses the last value for subsequent calls" do
-          expect(@double.do_something).to equal(11)
-          expect(@double.do_something).to equal(22)
-          expect(@double.do_something).to equal(22)
-          verify @double
-        end
-
-        it "fails when called less than the specified number" do
-          expect(@double.do_something).to equal(11)
-          expect { verify @double }.to raise_error(RSpec::Mocks::MockExpectationError)
-        end
-      end
-    end
-
-    describe "a message expectation with multiple return values with a specified count larger than the number of values" do
-      before(:each) do
-        @double = RSpec::Mocks::Double.new("double")
-        @double.should_receive(:do_something).exactly(3).times.and_return(11, 22)
-      end
-
-      it "uses the last return value for subsequent calls" do
-        expect(@double.do_something).to equal(11)
-        expect(@double.do_something).to equal(22)
-        expect(@double.do_something).to equal(22)
-        verify @double
-      end
-
-      it "fails when called less than the specified number" do
-        @double.do_something
-        @double.do_something
-        expect { verify @double }.to raise_error
-      end
-
-      it "fails fast when called greater than the specified number" do
-        @double.do_something
-        @double.do_something
-        @double.do_something
-        expect { @double.do_something }.to raise_error
-      end
-    end
-  end
-end