rspec-mocks 3.0.0.beta1 → 3.0.0.beta2

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

@@ -64,7 +64,7 @@ module RSpec
       let(:expectation_error) do
         failure = nil
         begin
-          RSpec::Mocks.space.verify_all
+          verify_all
         rescue RSpec::Mocks::MockExpectationError => error
           failure = error
         end
@@ -74,7 +74,7 @@ module RSpec
       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
+        expect { verify_all }.to raise_error RSpec::Mocks::MockExpectationError
       end
 
       it 'fails with a sensible message' do

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

@@ -5,10 +5,6 @@ module RSpec
     describe Matchers::Receive do
       include_context "with syntax", :expect
 
-      def verify_all
-        ::RSpec::Mocks.space.verify_all
-      end
-
       describe "expectations/allowances on any instance recorders" do
         include_context "with syntax", [:expect, :should]
 
@@ -93,6 +89,24 @@ module RSpec
           expect(receiver.foo(1)).to eq(:a)
           expect(receiver.foo(2)).to eq(:b)
         end
+
+        it 'allows do...end blocks to be passed to the fluent interface methods without getting a warning' do
+          expect(RSpec).not_to receive(:warning)
+
+          wrapped.to receive(:foo).with(1) do
+            :a
+          end
+
+          expect(receiver.foo(1)).to eq(:a)
+        end
+
+        it 'makes { } blocks trump do...end blocks when passed to a fluent interface method' do
+          wrapped.to receive(:foo).with(1) { :curly } do
+            :do_end
+          end
+
+          expect(receiver.foo(1)).to eq(:curly)
+        end
       end
 
       shared_examples_for "an expect syntax allowance" do |*options|
@@ -207,7 +221,7 @@ module RSpec
         it "removes the method double" do
           target.to receive(:foo).and_return(:baz)
           expect {
-            ::RSpec::Mocks.space.verify_all
+            verify_all
           }.to change { object.foo }.from(:baz).to(:bar)
         end
       end
@@ -402,4 +416,3 @@ module RSpec
     end
   end
 end
-

data/spec/rspec/mocks/method_signature_verifier_spec.rb

@@ -0,0 +1,272 @@
+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

@@ -24,4 +24,3 @@ module RSpec
     end
   end
 end
-

data/spec/rspec/mocks/multiple_return_value_spec.rb

@@ -56,7 +56,7 @@ module RSpec
       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])
+        @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
@@ -104,7 +104,7 @@ module RSpec
 
     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::Mock.new("double")
+        @double = RSpec::Mocks::Double.new("double")
         @double.should_receive(:do_something).exactly(3).times.and_return(11, 22)
       end
 

data/spec/rspec/mocks/mutate_const_spec.rb

@@ -451,6 +451,18 @@ module RSpec
           it("returns nil for the original value")      { expect(const.original_value).to be_nil }
         end
 
+        context 'for a previously undefined parent of a stubbed constant' do
+          before { stub_const("TestClass::UndefinedModule::Undefined", :other) }
+          let(:const) { Constant.original("TestClass::UndefinedModule") }
+
+          it("exposes its name")                        { expect(const.name).to eq("TestClass::UndefinedModule") }
+          it("indicates it was not previously defined") { expect(const).not_to be_previously_defined }
+          it("indicates it has been mutated")           { expect(const).to be_mutated }
+          it("indicates it has been stubbed")           { expect(const).to be_stubbed }
+          it("indicates it has not been hidden")        { expect(const).not_to be_hidden }
+          it("returns nil for the original value")      { expect(const.original_value).to be_nil }
+        end
+
         context 'for a previously undefined unstubbed constant' do
           let(:const) { Constant.original("TestClass::Undefined") }
 
@@ -488,6 +500,18 @@ module RSpec
           it("returns nil for the original value")      { expect(const.original_value).to be_nil }
         end
 
+        context 'for a previously undefined hidden constant' do
+          before { hide_const("SomeUndefinedConst") }
+          let(:const) { Constant.original("SomeUndefinedConst") }
+
+          it("exposes its name")                      { expect(const.name).to eq("SomeUndefinedConst") }
+          it("indicates it was previously undefined") { expect(const).not_to be_previously_defined }
+          it("indicates it has not been mutated")     { expect(const).not_to be_mutated }
+          it("indicates it has not not been stubbed") { expect(const).not_to be_stubbed }
+          it("indicates it has not been hidden")      { expect(const).not_to be_hidden }
+          it("returns nil for the original value")    { expect(const.original_value).to be_nil }
+        end
+
         context 'for a previously defined hidden constant' do
           before { hide_const("TestClass::M") }
           let(:const) { Constant.original("TestClass::M") }
@@ -516,4 +540,3 @@ module RSpec
     end
   end
 end
-

data/spec/rspec/mocks/nil_expectation_warning_spec.rb

@@ -1,14 +1,5 @@
 require 'spec_helper'
 
-def remove_last_describe_from_world
-  RSpec::world.example_groups.pop
-end
-
-def empty_example_group
-  RSpec::Core::ExampleGroup.describe(Object, 'Empty Behaviour Group') { }
-  remove_last_describe_from_world
-end
-
 module RSpec
   module Mocks
     describe "an expectation set on nil" do
@@ -44,18 +35,12 @@ module RSpec
 
     describe "#allow_message_expectations_on_nil" do
       it "does not affect subsequent examples" do
-        example_group = ::RSpec::Core::ExampleGroup.describe
-        reporter      = ::RSpec.configuration.reporter
-        example_group.it("when called in one example that doesn't end up setting an expectation on nil") do
-                        allow_message_expectations_on_nil
-                      end
-        example_group.it("should not effect the next example ran") do
-                        Kernel.should_receive(:warn)
-                        nil.should_receive(:foo)
-                        nil.foo
-                      end
-
-        expect(example_group.run reporter).to eq true
+        allow_message_expectations_on_nil
+        RSpec::Mocks.teardown
+        RSpec::Mocks.setup
+        Kernel.should_receive(:warn)
+        nil.should_receive(:foo)
+        nil.foo
       end
 
       it 'doesnt error when marshalled' do
@@ -65,4 +50,3 @@ module RSpec
     end
   end
 end
-