Add tests (and feature sniffing) for mocking kwarg methods

Author: jhottenstein

spec/rspec/mocks/and_call_original_spec.rb

@@ -12,8 +12,24 @@ def meth_2(x)
           yield x, :additional_yielded_arg
         end
 
-        def meth_3(x:)
-          x
+        if RSpec::Support::RubyFeatures.kw_args_supported?
+          binding.eval(<<-RUBY, __FILE__, __LINE__)
+          def meth_3(**kwargs)
+            kwargs
+          end
+
+          def meth_4(x: 1)
+            x
+          end
+          RUBY
+        end
+
+        if RSpec::Support::RubyFeatures.required_kw_args_supported?
+          binding.eval(<<-RUBY, __FILE__, __LINE__)
+          def meth_5(x:)
+            x
+          end
+          RUBY
         end
 
         def self.new_instance
@@ -129,9 +145,32 @@ def inst.foo; :bar; end
         expect(klass.new.meth_1).to eq(:original)
       end
 
-      it 'works for instance methods that use keyword arguments' do
-        expect_any_instance_of(klass).to receive(:meth_3).and_call_original
-        expect(klass.new.meth_3(x: :kwarg)).to eq(:kwarg)
+      if RSpec::Support::RubyFeatures.kw_args_supported?
+        binding.eval(<<-RUBY, __FILE__, __LINE__)
+        it 'works for instance methods that use double splat' do
+          expect_any_instance_of(klass).to receive(:meth_3).and_call_original
+          expect(klass.new.meth_3(x: :kwarg)).to eq({x: :kwarg})
+        end
+
+        it 'works for instance methods that use optional keyword arguments' do
+          expect_any_instance_of(klass).to receive(:meth_4).and_call_original
+          expect(klass.new.meth_4).to eq(1)
+        end
+
+        it 'works for instance methods that use optional keyword arguments with an argument supplied' do
+          expect_any_instance_of(klass).to receive(:meth_4).and_call_original
+          expect(klass.new.meth_4(x: :kwarg)).to eq(:kwarg)
+        end
+        RUBY
+      end
+
+      if RSpec::Support::RubyFeatures.required_kw_args_supported?
+        binding.eval(<<-RUBY, __FILE__, __LINE__)
+        it 'works for instance methods that use required keyword arguments' do
+          expect_any_instance_of(klass).to receive(:meth_5).and_call_original
+          expect(klass.new.meth_5(x: :kwarg)).to eq(:kwarg)
+        end
+        RUBY
       end
 
       it 'works for instance methods defined on the superclass of the class' do

spec/rspec/mocks/matchers/receive_spec.rb

@@ -62,12 +62,44 @@ module Mocks
           expect(receiver.foo).to eq(4)
         end
 
-        it 'allows a `do...end` block implementation with keyword args to be provided' do
-          wrapped.to receive(:foo) do |**kwargs|
-            kwargs[:kw]
+        if RSpec::Support::RubyFeatures.kw_args_supported?
+          binding.eval(<<-RUBY, __FILE__, __LINE__)
+          it 'allows a `do...end` block implementation with keyword args to be provided' do
+            wrapped.to receive(:foo) do |**kwargs|
+              kwargs[:kw]
+            end
+
+            expect(receiver.foo(kw: :arg)).to eq(:arg)
+          end
+
+          it 'allows a `do...end` block implementation with optional keyword args to be provided' do
+            wrapped.to receive(:foo) do |kw: :arg|
+              kw
+            end
+
+            expect(receiver.foo(kw: 1)).to eq(1)
+          end
+
+          it 'allows a `do...end` block implementation with optional keyword args to be provided' do
+            wrapped.to receive(:foo) do |kw: :arg|
+              kw
+            end
+
+            expect(receiver.foo).to eq(:arg)
           end
+          RUBY
+        end
 
-          expect(receiver.foo(kw: :arg)).to eq(:arg)
+        if RSpec::Support::RubyFeatures.required_kw_args_supported?
+          binding.eval(<<-RUBY, __FILE__, __LINE__)
+          it 'allows a `do...end` block implementation with required keyword args' do
+            wrapped.to receive(:foo) do |kw:|
+              kw
+            end
+
+            expect(receiver.foo(kw: :arg)).to eq(:arg)
+          end
+          RUBY
         end
 
         it 'allows chaining off a `do...end` block implementation to be provided' do