opal-rspec 0.8.0 → 1.0.0.alpha1

data/rspec-expectations/upstream/features/built_in_matchers/include.feature

@@ -1,16 +1,19 @@
 Feature: `include` matcher
 
-  Use the include matcher to specify that a collection includes one or more expected objects.
-  This works on any object that responds to #include?  (such as a string or array):
+  Use the `include` matcher to specify that a collection includes one or more expected objects. It succeeds if any object of the given collection passes the specified matcher. This works on any object that responds to `#include?` (such as a string or array):
 
     ```ruby
     expect("a string").to include("a")
-    expect("a string").to include("str")
+    expect("a string").to include(/a|str/).twice
     expect("a string").to include("str", "g")
     expect("a string").not_to include("foo")
 
     expect([1, 2]).to include(1)
     expect([1, 2]).to include(1, 2)
+    expect([1, 2]).to include(a_kind_of(Integer))
+    expect([1, 2]).to include(be_odd.and be < 10 )
+    expect([1, 2]).to include(be_odd)
+    expect([1, 2]).to include(be < 10).at_least(2).times
     expect([1, 2]).not_to include(17)
     ```
 
@@ -21,6 +24,8 @@ Feature: `include` matcher
     expect(:a => 1, :b => 2).to include(:a, :b)
     expect(:a => 1, :b => 2).to include(:a => 1)
     expect(:a => 1, :b => 2).to include(:b => 2, :a => 1)
+    expect(:a => 1, :b => 2).to include(match(/b/) => 2)
+    expect(:a => 1, :b => 2).to include(match(/b/) => be_even)
     expect(:a => 1, :b => 2).not_to include(:c)
     expect(:a => 1, :b => 2).not_to include(:a => 2)
     expect(:a => 1, :b => 2).not_to include(:c => 3)
@@ -35,11 +40,17 @@ Feature: `include` matcher
         it { is_expected.to include(7) }
         it { is_expected.to include(1, 7) }
         it { is_expected.to include(1, 3, 7) }
+        it { is_expected.to include(a_kind_of(Integer)) }
+        it { is_expected.to include(be_odd.and be < 10) }
+        it { is_expected.to include(be_odd).at_least(:twice) }
+        it { is_expected.not_to include(be_even) }
         it { is_expected.not_to include(17) }
         it { is_expected.not_to include(43, 100) }
 
         # deliberate failures
         it { is_expected.to include(4) }
+        it { is_expected.to include(be_even) }
+        it { is_expected.to include(be_odd).at_most(2).times }
         it { is_expected.not_to include(1) }
         it { is_expected.not_to include(3) }
         it { is_expected.not_to include(7) }
@@ -52,14 +63,16 @@ Feature: `include` matcher
       """
     When I run `rspec array_include_matcher_spec.rb`
     Then the output should contain all of these:
-      | 14 examples, 7 failures                       |
-      | expected [1, 3, 7] to include 4               |
-      | expected [1, 3, 7] not to include 1           |
-      | expected [1, 3, 7] not to include 3           |
-      | expected [1, 3, 7] not to include 7           |
-      | expected [1, 3, 7] not to include 1, 3, and 7 |
-      | expected [1, 3, 7] to include 1 and 9         |
-      | expected [1, 3, 7] not to include 1 and 9     |
+      | 20 examples, 9 failures                                                         |
+      | expected [1, 3, 7] to include 4                                                 |
+      | expected [1, 3, 7] to include (be even)                                         |
+      | expected [1, 3, 7] to include (be odd) at most twice but it is included 3 times |
+      | expected [1, 3, 7] not to include 1                                             |
+      | expected [1, 3, 7] not to include 3                                             |
+      | expected [1, 3, 7] not to include 7                                             |
+      | expected [1, 3, 7] not to include 1, 3, and 7                                   |
+      | expected [1, 3, 7] to include 9                                                 |
+      | expected [1, 3, 7] not to include 1                                             |
 
   Scenario: string usage
     Given a file named "string_include_matcher_spec.rb" with:
@@ -67,23 +80,26 @@ Feature: `include` matcher
       RSpec.describe "a string" do
         it { is_expected.to include("str") }
         it { is_expected.to include("a", "str", "ng") }
+        it { is_expected.to include(/a|str/).twice }
         it { is_expected.not_to include("foo") }
         it { is_expected.not_to include("foo", "bar") }
 
         # deliberate failures
         it { is_expected.to include("foo") }
         it { is_expected.not_to include("str") }
+        it { is_expected.to include("str").at_least(:twice) }
         it { is_expected.to include("str", "foo") }
         it { is_expected.not_to include("str", "foo") }
       end
       """
     When I run `rspec string_include_matcher_spec.rb`
     Then the output should contain all of these:
-      | 8 examples, 4 failures                             |
-      | expected "a string" to include "foo"               |
-      | expected "a string" not to include "str"           |
-      | expected "a string" to include "str" and "foo"     |
-      | expected "a string" not to include "str" and "foo" |
+      | 10 examples, 5 failures                                                     |
+      | expected "a string" to include "foo"                                        |
+      | expected "a string" not to include "str"                                    |
+      | expected "a string" to include "str" at least twice but it is included once |
+      | expected "a string" to include "foo"                                        |
+      | expected "a string" not to include "str"                                    |
 
   Scenario: hash usage
     Given a file named "hash_include_matcher_spec.rb" with:
@@ -119,5 +135,46 @@ Feature: `include` matcher
       end
       """
     When I run `rspec hash_include_matcher_spec.rb`
-    Then the output should contain "13 failure"
+    Then the output should contain all of these:
+      | 22 examples, 13 failures                                      |
+      | expected {:a => 7, :b => 5} not to include :a                 |
+      | expected {:a => 7, :b => 5} not to include :b and :a          |
+      | expected {:a => 7, :b => 5} not to include {:a => 7}          |
+      | expected {:a => 7, :b => 5} not to include {:a => 7, :b => 5} |
+      | expected {:a => 7, :b => 5} to include :c                     |
+      | expected {:a => 7, :b => 5} to include :c and :d              |
+      | expected {:a => 7, :b => 5} to include {:d => 2}              |
+      | expected {:a => 7, :b => 5} to include {:a => 5}              |
+      | expected {:a => 7, :b => 5} to include {:a => 5, :b => 7}     |
+      | expected {:a => 7, :b => 5} to include :d                     |
+      | expected {:a => 7, :b => 5} not to include :a                 |
+      | expected {:a => 7, :b => 5} to include {:d => 3}              |
+      | expected {:a => 7, :b => 5} not to include {:a => 7}          |
+
+  Scenario: counts usage
+    Given a file named "include_matcher_with_counts_spec.rb" with:
+      """ruby
+        RSpec.describe [{:c => 7}, {:a => 1}, {:b => 2}, {:c => 1}, {:a => 3}, {:c => 7}] do
+          it { is_expected.to include(:b => 2).exactly(1).times }
+          it { is_expected.to include(:b => 2).once }
+          it { is_expected.to include(have_key(:a)).twice }
+          it { is_expected.to include(have_key(:c)).at_least(2).times }
+          it { is_expected.to include(have_key(:a)).at_least(:once) }
+          it { is_expected.to include(have_key(:c)).at_least(:twice) }
+          it { is_expected.to include(have_key(:d)).at_most(:once) }
+          it { is_expected.to include(have_key(:b)).at_most(:twice) }
 
+          # deliberate failures
+          it { is_expected.not_to include(have_key(:b)).once }
+          it { is_expected.not_to include(have_key(:a)).twice }
+          it { is_expected.not_to include(have_key(:c)).at_least(2).times }
+          it { is_expected.not_to include(have_key(:d)).at_most(:once) }
+        end
+      """
+    When I run `rspec include_matcher_with_counts_spec.rb`
+    Then the output should contain all of these:
+      | 12 examples, 4 failures                                                                                                 |
+      | expected [{:c => 7}, {:a => 1}, {:b => 2}, {:c => 1}, {:a => 3}, {:c => 7}] not to include (have key :b) once           |
+      | expected [{:c => 7}, {:a => 1}, {:b => 2}, {:c => 1}, {:a => 3}, {:c => 7}] not to include (have key :a) twice          |
+      | expected [{:c => 7}, {:a => 1}, {:b => 2}, {:c => 1}, {:a => 3}, {:c => 7}] not to include (have key :c) at least twice |
+      | expected [{:c => 7}, {:a => 1}, {:b => 2}, {:c => 1}, {:a => 3}, {:c => 7}] not to include (have key :d) at most once   |

data/rspec-expectations/upstream/features/built_in_matchers/match.feature

@@ -1,7 +1,7 @@
 Feature: `match` matcher
 
-  The match matcher calls `#match` on the object, passing if `#match` returns a truthy (not
-  `false` or `nil`) value.  Regexp and String both provide a `#match` method.
+  The `match` matcher calls `#match` on the object, passing if `#match` returns a truthy (not
+  `false` or `nil`) value. `Regexp` and `String` both provide a `#match` method.
 
     ```ruby
     expect("a string").to match(/str/) # passes

data/rspec-expectations/upstream/features/built_in_matchers/output.feature

@@ -1,15 +1,22 @@
 Feature: `output` matcher
 
-  The `output` matcher provides a way to assert that the has emitted content to either
+  The `output` matcher provides a way to assert that the block has emitted content to either
   `$stdout` or `$stderr`.
 
   With no arg, passes if the block outputs `to_stdout` or `to_stderr`. With a string, passes
   if the blocks outputs that specific string `to_stdout` or `to_stderr`. With a regexp or
   matcher, passes if the blocks outputs a string `to_stdout` or `to_stderr` that matches.
 
-  Note: This matcher works by temporarily replacing `$stdout` or `$stderr`, so it's not able
-  to intercept stream output that explicitly uses `STDOUT`/`STDERR` or that uses a reference
-  to `$stdout`/`$stderr` that was stored before the matcher is used.
+  Note: `to_stdout` and `to_stderr` work by temporarily replacing `$stdout` or `$stderr`, so
+  they're not able to intercept stream output that explicitly uses `STDOUT`/`STDERR` or that
+  uses a reference to `$stdout`/`$stderr` that was stored before the matcher is used.
+
+  To capture output from any spawned subprocess as well, use `to_stdout_from_any_process`
+  or `to_stderr_from_any_process`. Output from any process that inherits the main process's
+  corresponding standard stream will be captured.
+
+  Note: `to_stdout_from_any_process` and `to_stderr_from_any_process` use tempfiles to
+  capture output, and are thus significantly (~30x) slower than `to_stdout` and `to_stderr`.
 
   Scenario: output_to_stdout matcher
     Given a file named "output_to_stdout_spec.rb" with:
@@ -66,3 +73,59 @@ Feature: `output` matcher
       | expected block to output "bar" to stderr, but output "foo\n" |
       | expected block to output "foo" to stderr, but output nothing |
       | expected block to output /bar/ to stderr, but output "foo\n" |
+
+  Scenario: output_to_stdout_from_any_process matcher
+    Given a file named "output_to_stdout_from_any_process_spec.rb" with:
+      """ruby
+      RSpec.describe "output.to_stdout_from_any_process matcher" do
+        specify { expect { system('printf foo') }.to output.to_stdout_from_any_process }
+        specify { expect { system('printf foo') }.to output("foo").to_stdout_from_any_process }
+        specify { expect { system('printf foo') }.to output(/foo/).to_stdout_from_any_process }
+        specify { expect { }.to_not output.to_stdout_from_any_process }
+        specify { expect { system('printf foo') }.to_not output("bar").to_stdout_from_any_process }
+        specify { expect { system('printf foo') }.to_not output(/bar/).to_stdout_from_any_process }
+
+        # deliberate failures
+        specify { expect { }.to output.to_stdout_from_any_process }
+        specify { expect { }.to output('foo').to_stdout_from_any_process }
+        specify { expect { system('printf foo') }.to_not output.to_stdout_from_any_process }
+        specify { expect { system('printf foo') }.to output('bar').to_stdout_from_any_process }
+        specify { expect { system('printf foo') }.to output(/bar/).to_stdout_from_any_process }
+      end
+      """
+    When I run `rspec output_to_stdout_from_any_process_spec.rb`
+    Then the output should contain all of these:
+      | 11 examples, 5 failures                                      |
+      | expected block to output to stdout, but did not              |
+      | expected block to not output to stdout, but output "foo"     |
+      | expected block to output "bar" to stdout, but output "foo"   |
+      | expected block to output "foo" to stdout, but output nothing |
+      | expected block to output /bar/ to stdout, but output "foo"   |
+
+  Scenario: output_to_stderr_from_any_process matcher
+    Given a file named "output_to_stderr_from_any_process_spec.rb" with:
+      """ruby
+      RSpec.describe "output.to_stderr_from_any_process matcher" do
+        specify { expect { system('printf foo 1>&2') }.to output.to_stderr_from_any_process }
+        specify { expect { system('printf foo 1>&2') }.to output("foo").to_stderr_from_any_process }
+        specify { expect { system('printf foo 1>&2') }.to output(/foo/).to_stderr_from_any_process }
+        specify { expect { }.to_not output.to_stderr_from_any_process }
+        specify { expect { system('printf foo 1>&2') }.to_not output("bar").to_stderr_from_any_process }
+        specify { expect { system('printf foo 1>&2') }.to_not output(/bar/).to_stderr_from_any_process }
+
+        # deliberate failures
+        specify { expect { }.to output.to_stderr_from_any_process }
+        specify { expect { }.to output('foo').to_stderr_from_any_process }
+        specify { expect { system('printf foo 1>&2') }.to_not output.to_stderr_from_any_process }
+        specify { expect { system('printf foo 1>&2') }.to output('bar').to_stderr_from_any_process }
+        specify { expect { system('printf foo 1>&2') }.to output(/bar/).to_stderr_from_any_process }
+      end
+      """
+    When I run `rspec output_to_stderr_from_any_process_spec.rb`
+    Then the output should contain all of these:
+      | 11 examples, 5 failures                                      |
+      | expected block to output to stderr, but did not              |
+      | expected block to not output to stderr, but output "foo"     |
+      | expected block to output "bar" to stderr, but output "foo"   |
+      | expected block to output "foo" to stderr, but output nothing |
+      | expected block to output /bar/ to stderr, but output "foo"   |

data/rspec-expectations/upstream/features/built_in_matchers/predicates.feature

@@ -39,7 +39,7 @@ Feature: Predicate matchers
 
   In either case, RSpec provides nice, clear error messages, such as:
 
-    `expected zero? to return true, got false`
+    `expected zero? to be truthy, got false`
 
   Calling private methods will also fail:
 
@@ -47,7 +47,7 @@ Feature: Predicate matchers
 
   Any arguments passed to the matcher will be passed on to the predicate method.
 
-  Scenario: should be_zero (based on Fixnum#zero?)
+  Scenario: should be_zero (based on Integer#zero?)
     Given a file named "should_be_zero_spec.rb" with:
       """ruby
       RSpec.describe 0 do
@@ -60,7 +60,7 @@ Feature: Predicate matchers
       """
     When I run `rspec should_be_zero_spec.rb`
     Then the output should contain "2 examples, 1 failure"
-     And the output should contain "expected `7.zero?` to return true, got false"
+     And the output should contain "expected `7.zero?` to be truthy, got false"
 
   Scenario: should_not be_empty (based on Array#empty?)
     Given a file named "should_not_be_empty_spec.rb" with:
@@ -75,7 +75,7 @@ Feature: Predicate matchers
       """
     When I run `rspec should_not_be_empty_spec.rb`
     Then the output should contain "2 examples, 1 failure"
-     And the output should contain "expected `[].empty?` to return false, got true"
+     And the output should contain "expected `[].empty?` to be falsey, got true"
 
    Scenario: should have_key (based on Hash#has_key?)
     Given a file named "should_have_key_spec.rb" with:
@@ -88,37 +88,38 @@ Feature: Predicate matchers
       """
     When I run `rspec should_have_key_spec.rb`
     Then the output should contain "2 examples, 1 failure"
-     And the output should contain "expected #has_key?(:bar) to return true, got false"
+     And the output should contain "expected `{:foo=>7}.has_key?(:bar)` to be truthy, got false"
 
    Scenario: should_not have_all_string_keys (based on custom #has_all_string_keys? method)
      Given a file named "should_not_have_all_string_keys_spec.rb" with:
        """ruby
-       class Hash
-         def has_all_string_keys?
-           keys.all? { |k| String === k }
+       class Float
+         def has_decimals?
+           round != self
          end
        end
 
-       RSpec.describe Hash do
-         context 'with symbol keys' do
-           subject { { :foo => 7, :bar => 5 } }
-           it { is_expected.not_to have_all_string_keys }
+       RSpec.describe Float do
+         context 'with decimals' do
+           subject { 4.2 }
+
+           it { is_expected.to have_decimals }
          end
 
-         context 'with string keys' do
-           subject { { 'foo' => 7, 'bar' => 5 } }
-           it { is_expected.not_to have_all_string_keys } # deliberate failure
+         context 'with no decimals' do
+           subject { 42.0 }
+           it { is_expected.to have_decimals } # deliberate failure
          end
        end
        """
      When I run `rspec should_not_have_all_string_keys_spec.rb`
      Then the output should contain "2 examples, 1 failure"
-      And the output should contain "expected #has_all_string_keys? to return false, got true"
+      And the output should contain "expected `42.0.has_decimals?` to be truthy, got false"
 
    Scenario: matcher arguments are passed on to the predicate method
      Given a file named "predicate_matcher_argument_spec.rb" with:
        """ruby
-       class Fixnum
+       class Integer
          def multiple_of?(x)
            (self % x).zero?
          end
@@ -135,8 +136,44 @@ Feature: Predicate matchers
        """
      When I run `rspec predicate_matcher_argument_spec.rb`
      Then the output should contain "4 examples, 2 failures"
-      And the output should contain "expected `12.multiple_of?(4)` to return false, got true"
-      And the output should contain "expected `12.multiple_of?(5)` to return true, got false"
+      And the output should contain "expected `12.multiple_of?(4)` to be falsey, got true"
+      And the output should contain "expected `12.multiple_of?(5)` to be truthy, got false"
+
+    Scenario: the config `strict_predicate_matchers` impacts matching of results other than `true` and `false`
+      Given a file named "strict_or_not.rb" with:
+        """ruby
+        class StrangeResult
+          def has_strange_result?
+            42
+          end
+        end
+
+        RSpec.describe StrangeResult do
+          subject { StrangeResult.new }
+
+          before do
+            RSpec.configure do |config|
+              config.expect_with :rspec do |expectations|
+                expectations.strict_predicate_matchers = strict
+              end
+            end
+          end
+
+          context 'with non-strict matchers (default)' do
+            let(:strict) { false }
+            it { is_expected.to have_strange_result }
+          end
+
+          context 'with strict matchers' do
+            let(:strict) { true }
+            # deliberate failure
+            it { is_expected.to have_strange_result }
+          end
+        end
+        """
+      When I run `rspec strict_or_not.rb`
+      Then the output should contain "2 examples, 1 failure"
+      And the output should contain "has_strange_result?` to return true, got 42"
 
     Scenario: calling private method with be_predicate causes error
       Given a file named "attempting_to_match_private_method_spec.rb" with:

data/rspec-expectations/upstream/features/built_in_matchers/raise_error.feature

@@ -26,6 +26,7 @@ Feature: `raise_error` matcher
     expect { raise "oops" }.to raise_error(/op/)
     expect { raise "oops" }.to raise_error(RuntimeError, "oops")
     expect { raise "oops" }.to raise_error(RuntimeError, /op/)
+    expect { raise "oops" }.to raise_error(an_instance_of(RuntimeError).and having_attributes(message: "oops"))
     ```
 
   Scenario: expect any error
@@ -91,7 +92,7 @@ Feature: `raise_error` matcher
     When I run `rspec example_spec.rb`
     Then the example should pass
 
-  Scenario: match type + message with string
+  Scenario: match class + message with string
     Given a file named "example_spec.rb" with:
       """ruby
       RSpec.describe "matching error message with string" do
@@ -104,7 +105,7 @@ Feature: `raise_error` matcher
     When I run `rspec example_spec.rb`
     Then the example should pass
 
-  Scenario: match type + message with regexp
+  Scenario: match class + message with regexp
     Given a file named "example_spec.rb" with:
       """ruby
       RSpec.describe "matching error message with regex" do
@@ -131,6 +132,19 @@ Feature: `raise_error` matcher
       When I run `rspec example_spec`
       Then the example should pass
 
+  Scenario: set expectations on error object with chained matchers
+    Given a file named "example_spec" with:
+      """
+      RSpec.describe "composing matchers" do
+        it "raises StandardError" do
+          expect { raise StandardError, "my message" }.
+            to raise_error(an_instance_of(StandardError).and having_attributes({"message" => "my message"}))
+        end
+      end
+      """
+      When I run `rspec example_spec`
+      Then the example should pass
+
   Scenario: expect no error at all
     Given a file named "example_spec" with:
       """

data/rspec-expectations/upstream/features/built_in_matchers/respond_to.feature

@@ -1,6 +1,6 @@
 Feature: `respond_to` matcher
 
-  Use the respond_to matcher to specify details of an object's interface.  In its most basic form:
+  Use the `respond_to` matcher to specify details of an object's interface. In its most basic form:
 
     ```ruby
     expect(obj).to respond_to(:foo) # pass if obj.respond_to?(:foo)
@@ -19,10 +19,21 @@ Feature: `respond_to` matcher
     ```ruby
     expect(obj).to respond_to(:foo).with(1).argument
     expect(obj).to respond_to(:bar).with(2).arguments
+    expect(obj).to respond_to(:baz).with(1..2).arguments
+    expect(obj).to respond_to(:xyz).with_unlimited_arguments
     ```
 
-  Note that this matcher relies entirely upon #respond_to?.  If an object dynamically responds
-  to a message via #method_missing, but does not indicate this via #respond_to?, then this
+  If your Ruby version supports keyword arguments, you can specify a list of keywords accepted
+  by the method.
+
+    ```ruby
+    expect(obj).to respond_to(:foo).with_keywords(:ichi, :ni)
+    expect(obj).to respond_to(:bar).with(2).arguments.and_keywords(:san, :yon)
+    expect(obj).to respond_to(:baz).with_arbitrary_keywords
+    ```
+
+  Note that this matcher relies entirely upon `#respond_to?`.  If an object dynamically responds
+  to a message via `#method_missing`, but does not indicate this via `#respond_to?`, then this
   matcher will give you false results.
 
   Scenario: basic usage
@@ -81,3 +92,180 @@ Feature: `respond_to` matcher
       | expected 7 not to respond to :zero? with 0 arguments    |
       | expected 7 to respond to :between? with 7 arguments     |
       | expected 7 not to respond to :between? with 2 arguments |
+
+  @skip-when-splat-args-unsupported
+  Scenario: specify arguments range
+    Given a file named "respond_to_matcher_argument_range_checking_spec.rb" with:
+      """ruby
+      class MyClass
+        def build(name, options = {})
+        end
+
+        def inspect
+          'my_object'
+        end
+      end
+
+      RSpec.describe MyClass do
+        it { is_expected.to respond_to(:build).with(1..2).arguments }
+        it { is_expected.not_to respond_to(:build).with(0..1).arguments }
+        it { is_expected.not_to respond_to(:build).with(2..3).arguments }
+        it { is_expected.not_to respond_to(:build).with(0..3).arguments }
+
+        # deliberate failures
+        it { is_expected.not_to respond_to(:build).with(1..2).arguments }
+        it { is_expected.to respond_to(:build).with(0..1).arguments }
+        it { is_expected.to respond_to(:build).with(2..3).arguments }
+        it { is_expected.to respond_to(:build).with(0..3).arguments }
+      end
+      """
+    When I run `rspec respond_to_matcher_argument_range_checking_spec.rb`
+    Then the output should contain all of these:
+      | 8 examples, 4 failures                                          |
+      | expected my_object not to respond to :build with 1..2 arguments |
+      | expected my_object to respond to :build with 0..1 arguments     |
+      | expected my_object to respond to :build with 2..3 arguments     |
+      | expected my_object to respond to :build with 0..3 arguments     |
+
+  @skip-when-splat-args-unsupported
+  Scenario: specify unlimited arguments
+  Given a file named "respond_to_matcher_unlimited_argument_checking_spec.rb" with:
+      """ruby
+      class MyClass
+        def greet(message = 'Hello', *people)
+        end
+
+        def hail(person)
+        end
+
+        def inspect
+          'my_object'
+        end
+      end
+
+      RSpec.describe MyClass do
+        it { is_expected.to respond_to(:greet).with_unlimited_arguments }
+        it { is_expected.to respond_to(:greet).with(1).argument.and_unlimited_arguments }
+        it { is_expected.not_to respond_to(:hail).with_unlimited_arguments }
+        it { is_expected.not_to respond_to(:hail).with(1).argument.and_unlimited_arguments }
+
+        # deliberate failures
+        it { is_expected.not_to respond_to(:greet).with_unlimited_arguments }
+        it { is_expected.not_to respond_to(:greet).with(1).argument.and_unlimited_arguments }
+        it { is_expected.to respond_to(:hail).with_unlimited_arguments }
+        it { is_expected.to respond_to(:hail).with(1).argument.and_unlimited_arguments }
+      end
+      """
+    When I run `rspec respond_to_matcher_unlimited_argument_checking_spec.rb`
+    Then the output should contain all of these:
+      | 8 examples, 4 failures                                                              |
+      | expected my_object not to respond to :greet with unlimited arguments                |
+      | expected my_object not to respond to :greet with 1 argument and unlimited arguments |
+      | expected my_object to respond to :hail with unlimited arguments                     |
+      | expected my_object to respond to :hail with 1 argument and unlimited arguments      |
+
+  @skip-when-keyword-args-unsupported
+  Scenario: specify keywords
+    Given a file named "respond_to_matcher_keyword_checking_spec.rb" with:
+      """ruby
+      class MyClass
+        def find(name = 'id', limit: 1_000, offset: 0)
+          []
+        end
+
+        def inspect
+          'my_object'
+        end
+      end
+
+      RSpec.describe MyClass do
+        it { is_expected.to respond_to(:find).with_keywords(:limit, :offset) }
+        it { is_expected.to respond_to(:find).with(1).argument.and_keywords(:limit, :offset) }
+
+        it { is_expected.not_to respond_to(:find).with_keywords(:limit, :offset, :page) }
+        it { is_expected.not_to respond_to(:find).with(1).argument.and_keywords(:limit, :offset, :page) }
+
+        # deliberate failures
+        it { is_expected.to respond_to(:find).with_keywords(:limit, :offset, :page) }
+        it { is_expected.to respond_to(:find).with(1).argument.and_keywords(:limit, :offset, :page) }
+
+        it { is_expected.not_to respond_to(:find).with_keywords(:limit, :offset) }
+        it { is_expected.not_to respond_to(:find).with(1).argument.and_keywords(:limit, :offset) }
+      end
+      """
+    When I run `rspec respond_to_matcher_keyword_checking_spec.rb`
+    Then the output should contain all of these:
+      | 8 examples, 4 failures                                                                         |
+      | expected my_object to respond to :find with keywords :limit, :offset, and :page                |
+      | expected my_object to respond to :find with 1 argument and keywords :limit, :offset, and :page |
+      | expected my_object not to respond to :find with keywords :limit and :offset                    |
+      | expected my_object not to respond to :find with 1 argument and keywords :limit and :offset     |
+
+  @skip-when-keyword-args-unsupported
+  Scenario: specify any keywords
+    Given a file named "respond_to_matcher_any_keywords_checking_spec.rb" with:
+      """ruby
+      class MyClass
+        def build(name: 'object', **opts)
+        end
+
+        def create(name: 'object', type: String)
+        end
+
+        def inspect
+          'my_object'
+        end
+      end
+
+      RSpec.describe MyClass do
+        it { is_expected.to respond_to(:build).with_any_keywords }
+        it { is_expected.to respond_to(:build).with_keywords(:name).and_any_keywords }
+        it { is_expected.not_to respond_to(:create).with_any_keywords }
+        it { is_expected.not_to respond_to(:create).with_keywords(:name).and_any_keywords }
+
+        # deliberate failures
+        it { is_expected.not_to respond_to(:build).with_any_keywords }
+        it { is_expected.not_to respond_to(:build).with_keywords(:name).and_any_keywords }
+        it { is_expected.to respond_to(:create).with_any_keywords }
+        it { is_expected.to respond_to(:create).with_keywords(:name).and_any_keywords }
+      end
+      """
+    When I run `rspec respond_to_matcher_any_keywords_checking_spec.rb`
+    Then the output should contain all of these:
+      | 8 examples, 4 failures                                          |
+      | expected my_object not to respond to :build with any keywords |
+      | expected my_object not to respond to :build with keyword :name and any keywords |
+      | expected my_object to respond to :create with any keywords |
+      | expected my_object to respond to :create with keyword :name and any keywords |
+
+  @skip-when-required-keyword-args-unsupported
+  Scenario: specify required keywords
+    Given a file named "respond_to_matcher_required_keyword_checking_spec.rb" with:
+      """ruby
+      class MyClass
+        def plant(seed:, fertilizer: nil, water: 'daily')
+          []
+        end
+
+        def inspect
+          'my_object'
+        end
+      end
+
+      RSpec.describe MyClass do
+        it { is_expected.to respond_to(:plant).with_keywords(:seed) }
+        it { is_expected.to respond_to(:plant).with_keywords(:seed, :fertilizer, :water) }
+        it { is_expected.not_to respond_to(:plant).with_keywords(:fertilizer, :water) }
+
+        # deliberate failures
+        it { is_expected.not_to respond_to(:plant).with_keywords(:seed) }
+        it { is_expected.not_to respond_to(:plant).with_keywords(:seed, :fertilizer, :water) }
+        it { is_expected.to respond_to(:plant).with_keywords(:fertilizer, :water) }
+      end
+      """
+    When I run `rspec respond_to_matcher_required_keyword_checking_spec.rb`
+    Then the output should contain all of these:
+      | 6 examples, 3 failures                                                                   |
+      | expected my_object not to respond to :plant with keyword :seed                           |
+      | expected my_object not to respond to :plant with keywords :seed, :fertilizer, and :water |
+      | expected my_object to respond to :plant with keywords :fertilizer and :water             |