mocha 1.15.0 → 2.0.0.alpha.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c6be1c2dafee7237e2ff675159cbc86afd1b5a56493d2671eba64cc4fbb001dd
-  data.tar.gz: 2bde2824fd9b2f5a3ba6445f9f3e42e1e97053f235eb5fea647410f037a0cee2
+  metadata.gz: 97e7753fb6b5d10c44315d7b40ab4004dd1ee6224af909d983e2553d6541701b
+  data.tar.gz: 917eff26dfcbdfa01dc4c1befcb43556075d87b0b9929ac055498e2a9ec4e622
 SHA512:
-  metadata.gz: fd3c082fca1dd5123b1c7ac6dd65ba4c9a2e92ec8791dcbc6f3d4a9a9f9c8161cf8cf4b9058c7483f5419118cdfea6cfc17cc0b206964dfc98ed8271852ea5ee
-  data.tar.gz: 074fcc5048dd385eb929c03b5757c517eaceb0f72e8536500d867b3571f072a7aa29afc8a7a78a4ab0db3c7208a5c811c0a5754d30b9ebaec213ea1337f17eea
+  metadata.gz: 9421147bdeb37a99308e577e284248f0c2ddad246772d4822a0d97c11ed4e393e12f5157be6832d0bf7ab58b60227910282b5ec315615476b27ecc7ff67523fc
+  data.tar.gz: 1a63c4651b41de00f65ed771f1b22d0e6b63c1d795b9c36b195889fac3bd55168399d0b3a7cc6dfae77fcfdbfffce8098e8f5b6a8cef4fc49f481a533d844c6d

data/.rubocop.yml

@@ -1,7 +1,7 @@
 inherit_from: .rubocop_todo.yml
 
 AllCops:
-  TargetRubyVersion: 2.2 # closest to required_ruby_version of '>= 1.9'
+  TargetRubyVersion: 2.2 # closest to required_ruby_version of '>= 2.0'
 
 # Even the reference in the documentation suggests that you should prefer
 # `alias_method` vs `alias`, so I don't understand why that isn't the default.
@@ -48,6 +48,10 @@ Style/WhileUntilModifier:
 Style/AccessModifierDeclarations:
   Enabled: false
 
+# This is useful when using `ExecutionPoint.current` to make tests more robust
+Style/Semicolon:
+  Enabled: false
+
 # Enabling this cop results in an "Infinite loop detected" exception
 Layout/AccessModifierIndentation:
   Enabled: false

data/Gemfile

@@ -3,9 +3,7 @@ source 'https://rubygems.org'
 gemspec
 
 # rubocop:disable Bundler/DuplicatedGem
-if RUBY_VERSION < '2'
-  gem 'rake', '~> 12.2.1'
-elsif RUBY_VERSION < '2.2'
+if RUBY_VERSION < '2.2'
   gem 'rake', '~> 12.3.3'
 else
   gem 'rake'
@@ -30,3 +28,5 @@ if ENV['MOCHA_GENERATE_DOCS']
   gem 'redcarpet'
   gem 'yard'
 end
+
+gem 'ruby2_keywords', '~> 0.0.5'

data/RELEASE.md

@@ -1,5 +1,47 @@
 # Release Notes
 
+## 2.0.0.alpha.1
+
+### External changes
+
+* Improve strict keyword argument matching deprecation warning by including the source location of the stub definition (77c0d4cc)
+
+### Internal changes
+
+* Disable Style/Semicolon cop globally (8cd0b705)
+
+## 2.0.0.alpha
+
+### External changes
+
+* Remove support for Ruby v1.9 - thanks to @wasabigeek (#552)
+* Support strict keyword argument matching - see docs for `Expectation#with` & `Configuration#strict_keyword_argument_matching=` - thanks to @wasabigeek (#446,#535,#544,#562)
+* Deprecate `Hash` args that don't strictly match (#563,981c31be)
+* Drop support for older versions of test-unit - gem versions of test-unit earlier than v2.5.1 and versions of test-unit
+from the Ruby v1.8 standard library are no longer supported (#540,969f4845)
+* Drop support for older versions of minitest - versions of minitest earlier than v3.3.0 are no longer supported (#541,ca69dc9e)
+* Remove deprecated `mocha/setup.rb` mechanism (642a0ff4)
+* Add missing docs for `API#stub` parameter (257b4cb4)
+* Remove optional reinstatement of v1.9 behaviour (#436,#438,#569,1473ee25)
+* Remove deprecated methods in `Configuration` (#421,e7ff7528)
+* Fail fast when mock receives invocations in another test (#440,#442,cb054d59)
+* Improve docs re using matchers in `Expectation#with` (da7237cd)
+* Expand `Expectation#with` docs re keyword arguments (fed6808d)
+* Improve docs for `strict_keyword_argument_matching` (8d8f881d)
+* Remove deprecated Rails plugin `init.rb` file (1c617175)
+
+### Internal changes
+
+* Separate linting from tests in terms of Rake tasks & CircleCI jobs - thanks to @wasabigeek (#556)
+* Remove tests specific to Ruby v1.8 behaviour (46fca7ac, 3b369e99)
+* Multi-line rubocop disable in `Mock#method_missing` (af2194c4)
+* Remove unused arg for `HashMethods#mocha_inspect` (4f59e27f)
+* Improve test runner assertions - failure vs error (eec7200a)
+* Improve test coverage of `PositionalOrKeywordHash` (c294fe70)
+* More consistent Test::Unit & Minitest integration (27dd3817)
+* Remove redundant `require` statements (d82218a8,fa17b114)
+* Add missing `require` statement (73493761)
+
 ## 1.15.0
 
 ### External changes

data/Rakefile

@@ -5,9 +5,14 @@ end
 require 'bundler/setup'
 
 require 'rake/testtask'
+begin
+  # Only available with default Gemfile and in Ruby >= v2.2
+  require 'rubocop/rake_task'
+rescue LoadError # rubocop:disable Lint/HandleExceptions
+end
 
-desc 'Run all tests'
-task 'default' => ['test', 'test:performance']
+desc 'Run all linters and tests'
+task 'default' => ['lint', 'test', 'test:performance']
 
 desc 'Run tests'
 task 'test' do
@@ -76,13 +81,13 @@ namespace 'test' do # rubocop:disable Metrics/BlockLength
   end
 end
 
-begin
-  require 'rubocop/rake_task'
-  if RUBY_VERSION >= '2.2.0' && (defined?(RUBY_ENGINE) && RUBY_ENGINE == 'ruby') && ENV['MOCHA_RUN_INTEGRATION_TESTS'].nil?
+task 'lint' do
+  if defined?(RuboCop::RakeTask)
     RuboCop::RakeTask.new
-    task 'test' => 'rubocop'
+    Rake::Task['rubocop'].invoke
+  else
+    puts 'RuboCop not available - skipping linting'
   end
-rescue LoadError # rubocop:disable Lint/HandleExceptions
 end
 
 # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity

data/lib/mocha/api.rb

@@ -52,7 +52,6 @@ module Mocha
     #
     # @overload def mock(name)
     #   @param [String, Symbol] name identifies mock object in error messages.
-    #   @note Prior to v1.10.0 when +name+ was a +Symbol+, this method returned an unnamed +Mock+ that expected the method identified by +name+. This was undocumented behaviour and it will be removed in the future, but for the moment it can be reinstated using {Configuration#reinstate_undocumented_behaviour_from_v1_9=}.
     # @overload def mock(expected_methods_vs_return_values = {})
     #   @param [Hash] expected_methods_vs_return_values expected method name symbols as keys and corresponding return values as values - these expectations are setup as if {Mock#expects} were called multiple times.
     # @overload def mock(name, expected_methods_vs_return_values = {})
@@ -67,26 +66,8 @@ module Mocha
     #     # an error will be raised unless both Motor#start and Motor#stop have been called
     #   end
     #
-    def mock(*arguments) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
-      if Mocha.configuration.reinstate_undocumented_behaviour_from_v1_9?
-        if arguments.first.is_a?(Symbol)
-          method_name = arguments[0]
-          Deprecation.warning(
-            "Explicitly include `#{method_name}` in Hash of expected methods vs return values,",
-            " e.g. `mock(:#{method_name} => nil)`."
-          )
-          if arguments[1]
-            Deprecation.warning(
-              "In this case the 2nd argument for `mock(:##{method_name}, ...)` is ignored,",
-              ' but in the future a Hash of expected methods vs return values will be respected.'
-            )
-          end
-        elsif arguments.first.is_a?(String)
-          name = arguments.shift
-        end
-      elsif arguments.first.is_a?(String) || arguments.first.is_a?(Symbol)
-        name = arguments.shift
-      end
+    def mock(*arguments)
+      name = arguments.shift.to_s if arguments.first.is_a?(String) || arguments.first.is_a?(Symbol)
       expectations = arguments.shift || {}
       mock = name ? Mockery.instance.named_mock(name) : Mockery.instance.unnamed_mock
       mock.expects(expectations)
@@ -99,11 +80,11 @@ module Mocha
     #
     # @overload def stub(name)
     #   @param [String, Symbol] name identifies mock object in error messages.
-    #   @note Prior to v1.10.0 when +name+ was a +Symbol+, this method returned an unnamed +Mock+ that stubbed the method identified by +name+. This was undocumented behaviour and it will be removed in the future, but for the moment it can be reinstated using {Configuration#reinstate_undocumented_behaviour_from_v1_9=}.
     # @overload def stub(stubbed_methods_vs_return_values = {})
     #   @param [Hash] stubbed_methods_vs_return_values stubbed method name symbols as keys and corresponding return values as values - these stubbed methods are setup as if {Mock#stubs} were called multiple times.
     # @overload def stub(name, stubbed_methods_vs_return_values = {})
     #   @param [String, Symbol] name identifies mock object in error messages.
+    #   @param [Hash] stubbed_methods_vs_return_values stubbed method name symbols as keys and corresponding return values as values - these stubbed methods are setup as if {Mock#stubs} were called multiple times.
     #
     # @example Using stubbed_methods_vs_return_values Hash to setup stubbed methods.
     #   def test_motor_starts_and_stops
@@ -112,33 +93,13 @@ module Mocha
     #     assert motor.stop
     #     # an error will not be raised even if either Motor#start or Motor#stop has not been called
     #   end
-    # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
     def stub(*arguments)
-      if Mocha.configuration.reinstate_undocumented_behaviour_from_v1_9?
-        if arguments.first.is_a?(Symbol)
-          method_name = arguments[0]
-          Deprecation.warning(
-            "Explicitly include `#{method_name}` in Hash of stubbed methods vs return values,",
-            " e.g. `stub(:#{method_name} => nil)`."
-          )
-          if arguments[1]
-            Deprecation.warning(
-              "In this case the 2nd argument for `stub(:##{method_name}, ...)` is ignored,",
-              ' but in the future a Hash of stubbed methods vs return values will be respected.'
-            )
-          end
-        elsif arguments.first.is_a?(String)
-          name = arguments.shift
-        end
-      elsif arguments.first.is_a?(String) || arguments.first.is_a?(Symbol)
-        name = arguments.shift
-      end
+      name = arguments.shift.to_s if arguments.first.is_a?(String) || arguments.first.is_a?(Symbol)
       expectations = arguments.shift || {}
       stub = name ? Mockery.instance.named_mock(name) : Mockery.instance.unnamed_mock
       stub.stubs(expectations)
       stub
     end
-    # rubocop:enable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
 
     # Builds a mock object that accepts calls to any method. By default it will return +nil+ for any method call.
     #
@@ -146,7 +107,6 @@ module Mocha
     #
     # @overload def stub_everything(name)
     #   @param [String, Symbol] name identifies mock object in error messages.
-    #   @note Prior to v1.10.0 when +name+ was a +Symbol+, this method returned an unnamed +Mock+ that stubbed the method identified by +name+. This was undocumented behaviour and it will be removed in the future, but for the moment it can be reinstated using {Configuration#reinstate_undocumented_behaviour_from_v1_9=}.
     # @overload def stub_everything(stubbed_methods_vs_return_values = {})
     #   @param [Hash] stubbed_methods_vs_return_values stubbed method name symbols as keys and corresponding return values as values - these stubbed methods are setup as if {Mock#stubs} were called multiple times.
     # @overload def stub_everything(name, stubbed_methods_vs_return_values = {})
@@ -160,34 +120,14 @@ module Mocha
     #     assert_nil motor.irrelevant_method_2 # => no error raised
     #     assert motor.stop
     #   end
-    # rubocop:disable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
     def stub_everything(*arguments)
-      if Mocha.configuration.reinstate_undocumented_behaviour_from_v1_9?
-        if arguments.first.is_a?(Symbol)
-          method_name = arguments[0]
-          Deprecation.warning(
-            "Explicitly include `#{method_name}` in Hash of stubbed methods vs return values,",
-            " e.g. `stub_everything(:#{method_name} => nil)`."
-          )
-          if arguments[1]
-            Deprecation.warning(
-              "In this case the 2nd argument for `stub_everything(:##{method_name}, ...)` is ignored,",
-              ' but in the future a Hash of stubbed methods vs return values will be respected.'
-            )
-          end
-        elsif arguments.first.is_a?(String)
-          name = arguments.shift
-        end
-      elsif arguments.first.is_a?(String) || arguments.first.is_a?(Symbol)
-        name = arguments.shift
-      end
+      name = arguments.shift if arguments.first.is_a?(String) || arguments.first.is_a?(Symbol)
       expectations = arguments.shift || {}
       stub = name ? Mockery.instance.named_mock(name) : Mockery.instance.unnamed_mock
       stub.stub_everything
       stub.stubs(expectations)
       stub
     end
-    # rubocop:enable Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
 
     # Builds a new sequence which can be used to constrain the order in which expectations can occur.
     #

data/lib/mocha/configuration.rb

@@ -1,3 +1,5 @@
+require 'mocha/ruby_version'
+
 module Mocha
   # Allows setting of configuration options. See {Configuration} for the available options.
   #
@@ -43,7 +45,7 @@ module Mocha
       :stubbing_non_public_method => :allow,
       :stubbing_method_on_nil => :prevent,
       :display_matching_invocations_on_failure => false,
-      :reinstate_undocumented_behaviour_from_v1_9 => true
+      :strict_keyword_argument_matching => false
     }.freeze
 
     attr_reader :options
@@ -248,134 +250,54 @@ module Mocha
       @options[:display_matching_invocations_on_failure]
     end
 
-    # Reinstate undocumented behaviour from v1.9
-    #
-    # Previously when {API#mock}, {API#stub}, or {API#stub_everything} were called with the first argument being a symbol, they built an *unnamed* mock object *and* expected or stubbed the method identified by the symbol argument; subsequent arguments were ignored.
-    # Now these methods build a *named* mock with the name specified by the symbol argument; *no* methods are expected or stubbed and subsequent arguments *are* taken into account.
+    # Perform strict keyword argument comparison. Only supported in Ruby >= v2.7.
     #
-    # Previously if {Expectation#yields} or {Expectation#multiple_yields} was called on an expectation, but no block was given when the method was invoked, the instruction to yield was ignored.
-    # Now a +LocalJumpError+ is raised.
+    # When this option is set to +false+ a positional +Hash+ and a set of keyword arguments are treated the same during comparison, which can lead to false negatives in Ruby >= v3.0 (see examples below). However, a deprecation warning will be displayed if a positional +Hash+ matches a set of keyword arguments or vice versa. This is because {#strict_keyword_argument_matching=} will default to +true+ in the future.
     #
-    # Enabling this configuration option reinstates the previous behaviour, but displays a deprecation warning.
+    # For more details on keyword arguments in Ruby v3, refer to {https://www.ruby-lang.org/en/news/2019/12/12/separation-of-positional-and-keyword-arguments-in-ruby-3-0 this article}.
     #
-    # @param [Boolean] value +true+ to reinstate undocumented behaviour; enabled by default.
+    # Note that +Hash+-related matchers such as {ParameterMatchers#has_value} or {ParameterMatchers#has_key} will still treat a positional +Hash+ and a set of keyword arguments the same, so false negatives are still possible when they are used.
     #
-    # @example Reinstate undocumented behaviour for {API#mock}
-    #   Mocha.configure do |c|
-    #     c.reinstate_undocumented_behaviour_from_v1_9 = true
-    #   end
+    # This configuration option is +false+ by default to enable gradual adoption, but will be +true+ by default in the future.
     #
-    #   foo = mock(:bar)
-    #   foo.inspect # => #<Mock>
+    # @param [Boolean] value +true+ to enable strict keyword argument matching; +false+ by default.
     #
-    #   not all expectations were satisfied
-    #   unsatisfied expectations:
-    #   - expected exactly once, invoked never: #<Mock>.foo
+    # @example Loose keyword argument matching (default)
     #
-    # @example Reinstate undocumented behaviour for {API#stub}
-    #   Mocha.configure do |c|
-    #     c.reinstate_undocumented_behaviour_from_v1_9 = true
+    #   class Example
+    #     def foo(a, bar:); end
     #   end
     #
-    #   foo = stub(:bar)
-    #   foo.inspect # => #<Mock>
-    #   foo.bar # => nil
+    #   example = Example.new
+    #   example.expects(:foo).with('a', bar: 'b')
+    #   example.foo('a', { bar: 'b' })
+    #   # This passes the test, but would result in an ArgumentError in practice
     #
-    # @example Reinstate undocumented behaviour for {Expectation#yields}
-    #   foo = mock('foo')
-    #   foo.stubs(:my_method).yields(1, 2)
-    #   foo.my_method # => raises LocalJumpError when no block is supplied
+    # @example Strict keyword argument matching
     #
     #   Mocha.configure do |c|
-    #     c.reinstate_undocumented_behaviour_from_v1_9 = true
+    #     c.strict_keyword_argument_matching = true
     #   end
     #
-    #   foo = mock('foo')
-    #   foo.stubs(:my_method).yields(1, 2)
-    #   foo.my_method # => does *not* raise LocalJumpError when no block is supplied
+    #   class Example
+    #     def foo(a, bar:); end
+    #   end
     #
-    def reinstate_undocumented_behaviour_from_v1_9=(value)
-      @options[:reinstate_undocumented_behaviour_from_v1_9] = value
+    #   example = Example.new
+    #   example.expects(:foo).with('a', bar: 'b')
+    #   example.foo('a', { bar: 'b' })
+    #   # This now fails as expected
+    def strict_keyword_argument_matching=(value)
+      raise 'Strict keyword argument matching requires Ruby 2.7 and above.' unless Mocha::RUBY_V27_PLUS
+      @options[:strict_keyword_argument_matching] = value
     end
 
     # @private
-    def reinstate_undocumented_behaviour_from_v1_9?
-      @options[:reinstate_undocumented_behaviour_from_v1_9]
+    def strict_keyword_argument_matching?
+      @options[:strict_keyword_argument_matching]
     end
 
     class << self
-      # Allow the specified +action+.
-      #
-      # @param [Symbol] action one of +:stubbing_method_unnecessarily+, +:stubbing_method_on_non_mock_object+, +:stubbing_non_existent_method+, +:stubbing_non_public_method+, +:stubbing_method_on_nil+.
-      # @yield optional block during which the configuration change will be changed before being returned to its original value at the end of the block.
-      # @deprecated If a block is supplied, call {.override} with a +Hash+ containing an entry with the +action+ as the key and +:allow+ as the value. If no block is supplied, call the appropriate +action+ writer method with +value+ set to +:allow+ via {Mocha.configure}. The writer method will be the one of the following corresponding to the +action+:
-      #   * {#stubbing_method_unnecessarily=}
-      #   * {#stubbing_method_on_non_mock_object=}
-      #   * {#stubbing_non_existent_method=}
-      #   * {#stubbing_non_public_method=}
-      #   * {#stubbing_method_on_nil=}
-      def allow(action, &block)
-        if block_given?
-          Deprecation.warning("Use Mocha::Configuration.override(#{action}: :allow) with the same block")
-        else
-          Deprecation.warning("Use Mocha.configure { |c| c.#{action} = :allow }")
-        end
-        change_config action, :allow, &block
-      end
-
-      # @private
-      def allow?(action)
-        configuration.allow?(action)
-      end
-
-      # Warn if the specified +action+ is attempted.
-      #
-      # @param [Symbol] action one of +:stubbing_method_unnecessarily+, +:stubbing_method_on_non_mock_object+, +:stubbing_non_existent_method+, +:stubbing_non_public_method+, +:stubbing_method_on_nil+.
-      # @yield optional block during which the configuration change will be changed before being returned to its original value at the end of the block.
-      # @deprecated If a block is supplied, call {.override} with a +Hash+ containing an entry with the +action+ as the key and +:warn+ as the value. If no block is supplied, call the appropriate +action+ writer method with +value+ set to +:warn+ via {Mocha.configure}. The writer method will be the one of the following corresponding to the +action+:
-      #   * {#stubbing_method_unnecessarily=}
-      #   * {#stubbing_method_on_non_mock_object=}
-      #   * {#stubbing_non_existent_method=}
-      #   * {#stubbing_non_public_method=}
-      #   * {#stubbing_method_on_nil=}
-      def warn_when(action, &block)
-        if block_given?
-          Deprecation.warning("Use Mocha::Configuration.override(#{action}: :warn) with the same block")
-        else
-          Deprecation.warning("Use Mocha.configure { |c| c.#{action} = :warn }")
-        end
-        change_config action, :warn, &block
-      end
-
-      # @private
-      def warn_when?(action)
-        configuration.warn_when?(action)
-      end
-
-      # Raise a {StubbingError} if the specified +action+ is attempted.
-      #
-      # @param [Symbol] action one of +:stubbing_method_unnecessarily+, +:stubbing_method_on_non_mock_object+, +:stubbing_non_existent_method+, +:stubbing_non_public_method+, +:stubbing_method_on_nil+.
-      # @yield optional block during which the configuration change will be changed before being returned to its original value at the end of the block.
-      # @deprecated If a block is supplied, call {.override} with a +Hash+ containing an entry with the +action+ as the key and +:prevent+ as the value. If no block is supplied, call the appropriate +action+ writer method with +value+ set to +:prevent+ via {Mocha.configure}. The writer method will be the one of the following corresponding to the +action+:
-      #   * {#stubbing_method_unnecessarily=}
-      #   * {#stubbing_method_on_non_mock_object=}
-      #   * {#stubbing_non_existent_method=}
-      #   * {#stubbing_non_public_method=}
-      #   * {#stubbing_method_on_nil=}
-      def prevent(action, &block)
-        if block_given?
-          Deprecation.warning("Use Mocha::Configuration.override(#{action}: :prevent) with the same block")
-        else
-          Deprecation.warning("Use Mocha.configure { |c| c.#{action} = :prevent }")
-        end
-        change_config action, :prevent, &block
-      end
-
-      # @private
-      def prevent?(action)
-        configuration.prevent?(action)
-      end
-
       # @private
       def reset_configuration
         @configuration = nil

data/lib/mocha/expectation.rb

@@ -1,3 +1,4 @@
+require 'ruby2_keywords'
 require 'mocha/method_matcher'
 require 'mocha/parameters_matcher'
 require 'mocha/expectation_error'
@@ -11,6 +12,7 @@ require 'mocha/change_state_side_effect'
 require 'mocha/cardinality'
 require 'mocha/configuration'
 require 'mocha/block_matcher'
+require 'mocha/backtrace_filter'
 
 module Mocha
   # Methods on expectations returned from {Mock#expects}, {Mock#stubs}, {ObjectMethods#expects} and {ObjectMethods#stubs}.
@@ -187,17 +189,26 @@ module Mocha
       at_most(1)
     end
 
-    # Modifies expectation so that the expected method must be called with +expected_parameters+.
+    # Modifies expectation so that the expected method must be called with +expected_parameters_or_matchers+.
     #
-    # May be used with parameter matchers in {ParameterMatchers}.
+    # May be used with Ruby literals or variables for exact matching or with parameter matchers for less-specific matching, e.g. {ParameterMatchers#includes}, {ParameterMatchers#has_key}, etc. See {ParameterMatchers} for a list of all available parameter matchers.
     #
-    # @param [*Array] expected_parameters parameters expected.
+    # Positional arguments were separated from keyword arguments in Ruby v3 (see {https://www.ruby-lang.org/en/news/2019/12/12/separation-of-positional-and-keyword-arguments-in-ruby-3-0 this article}). In relation to this a new configuration option ({Configuration#strict_keyword_argument_matching=}) is available in Ruby >= 2.7.
+    #
+    # When {Configuration#strict_keyword_argument_matching=} is set to +false+ (which is currently the default), a positional +Hash+ and a set of keyword arguments passed to {#with} are treated the same for the purposes of parameter matching. However, a deprecation warning will be displayed if a positional +Hash+ matches a set of keyword arguments or vice versa. This is because {Configuration#strict_keyword_argument_matching=} will default to +true+ in the future.
+    #
+    # When {Configuration#strict_keyword_argument_matching=} is set to +true+, an actual positional +Hash+ will not match an expected set of keyword arguments; and vice versa, an actual set of keyword arguments will not match an expected positional +Hash+, i.e. the parameter matching is stricter.
+    #
+    # @see ParameterMatchers
+    # @see Configuration#strict_keyword_argument_matching=
+    #
+    # @param [*Array<Object,ParameterMatchers::Base>] expected_parameters_or_matchers expected parameter values or parameter matchers.
     # @yield optional block specifying custom matching.
-    # @yieldparam [*Array] actual_parameters parameters with which expected method was invoked.
+    # @yieldparam [*Array<Object>] actual_parameters parameters with which expected method was invoked.
     # @yieldreturn [Boolean] +true+ if +actual_parameters+ are acceptable.
     # @return [Expectation] the same expectation, thereby allowing invocations of other {Expectation} methods to be chained.
     #
-    # @example Expected method must be called with expected parameters.
+    # @example Expected method must be called with exact parameter values.
     #   object = mock()
     #   object.expects(:expected_method).with(:param1, :param2)
     #   object.expected_method(:param1, :param2)
@@ -208,6 +219,43 @@ module Mocha
     #   object.expected_method(:param3)
     #   # => verify fails
     #
+    # @example Expected method must be called with parameters matching parameter matchers.
+    #   object = mock()
+    #   object.expects(:expected_method).with(includes('string2'), anything)
+    #   object.expected_method(['string1', 'string2'], 'any-old-value')
+    #   # => verify succeeds
+    #
+    #   object = mock()
+    #   object.expects(:expected_method).with(includes('string2'), anything)
+    #   object.expected_method(['string1'], 'any-old-value')
+    #   # => verify fails
+    #
+    # @example Loose keyword argument matching (default)
+    #
+    #   class Example
+    #     def foo(a, bar:); end
+    #   end
+    #
+    #   example = Example.new
+    #   example.expects(:foo).with('a', bar: 'b')
+    #   example.foo('a', { bar: 'b' })
+    #   # This passes the test, but would result in an ArgumentError in practice
+    #
+    # @example Strict keyword argument matching
+    #
+    #   Mocha.configure do |c|
+    #     c.strict_keyword_argument_matching = true
+    #   end
+    #
+    #   class Example
+    #     def foo(a, bar:); end
+    #   end
+    #
+    #   example = Example.new
+    #   example.expects(:foo).with('a', bar: 'b')
+    #   example.foo('a', { bar: 'b' })
+    #   # This now fails as expected
+    #
     # @example Expected method must be called with a value divisible by 4.
     #   object = mock()
     #   object.expects(:expected_method).with() { |value| value % 4 == 0 }
@@ -218,10 +266,11 @@ module Mocha
     #   object.expects(:expected_method).with() { |value| value % 4 == 0 }
     #   object.expected_method(17)
     #   # => verify fails
-    def with(*expected_parameters, &matching_block)
-      @parameters_matcher = ParametersMatcher.new(expected_parameters, &matching_block)
+    def with(*expected_parameters_or_matchers, &matching_block)
+      @parameters_matcher = ParametersMatcher.new(expected_parameters_or_matchers, self, &matching_block)
       self
     end
+    ruby2_keywords(:with)
 
     # Modifies expectation so that the expected method must be called with a block.
     #
@@ -644,5 +693,11 @@ module Mocha
       signature << " #{@block_matcher.mocha_inspect}" if @block_matcher.mocha_inspect
       signature
     end
+
+    # @private
+    def definition_location
+      filter = BacktraceFilter.new
+      filter.filtered(backtrace)[0]
+    end
   end
 end

data/lib/mocha/inspect.rb

@@ -18,9 +18,9 @@ module Mocha
     end
 
     module HashMethods
-      def mocha_inspect(wrapped = true)
+      def mocha_inspect
         unwrapped = collect { |key, value| "#{key.mocha_inspect} => #{value.mocha_inspect}" }.join(', ')
-        wrapped ? "{#{unwrapped}}" : unwrapped
+        Hash.ruby2_keywords_hash?(self) ? unwrapped : "{#{unwrapped}}"
       end
     end
 

data/lib/mocha/integration/mini_test.rb

@@ -1,54 +1,26 @@
 require 'mocha/debug'
-
 require 'mocha/detection/mini_test'
-
-require 'mocha/integration/mini_test/nothing'
-require 'mocha/integration/mini_test/version_13'
-require 'mocha/integration/mini_test/version_140'
-require 'mocha/integration/mini_test/version_141'
-require 'mocha/integration/mini_test/version_142_to_172'
-require 'mocha/integration/mini_test/version_200'
-require 'mocha/integration/mini_test/version_201_to_222'
-require 'mocha/integration/mini_test/version_230_to_2101'
-require 'mocha/integration/mini_test/version_2110_to_2111'
-require 'mocha/integration/mini_test/version_2112_to_320'
 require 'mocha/integration/mini_test/adapter'
 
-require 'mocha/deprecation'
-
 module Mocha
   module Integration
     module MiniTest
       def self.activate
-        return false unless Detection::MiniTest.testcase
-        mini_test_version = Gem::Version.new(Detection::MiniTest.version)
+        target = Detection::MiniTest.testcase
+        return false unless target
 
+        mini_test_version = Gem::Version.new(Detection::MiniTest.version)
         Debug.puts "Detected MiniTest version: #{mini_test_version}"
 
-        integration_module = [
-          MiniTest::Adapter,
-          MiniTest::Version2112To320,
-          MiniTest::Version2110To2111,
-          MiniTest::Version230To2101,
-          MiniTest::Version201To222,
-          MiniTest::Version200,
-          MiniTest::Version142To172,
-          MiniTest::Version141,
-          MiniTest::Version140,
-          MiniTest::Version13,
-          MiniTest::Nothing
-        ].detect { |m| m.applicable_to?(mini_test_version) }
+        unless MiniTest::Adapter.applicable_to?(mini_test_version)
+          raise 'Versions of minitest earlier than v3.3.0 are not supported.'
+        end
 
-        target = Detection::MiniTest.testcase
-        unless target < integration_module
-          unless integration_module == MiniTest::Adapter
-            Deprecation.warning(
-              'Versions of minitest earlier than v3.3.0 will not be supported in future versions of Mocha.'
-            )
-          end
-          Debug.puts "Applying #{integration_module.description}"
-          target.send(:include, integration_module)
+        unless target < MiniTest::Adapter
+          Debug.puts "Applying #{MiniTest::Adapter.description}"
+          target.send(:include, MiniTest::Adapter)
         end
+
         true
       end
     end

data/lib/mocha/integration/test_unit/adapter.rb

@@ -12,7 +12,7 @@ module Mocha
         include Mocha::API
 
         # @private
-        def self.applicable_to?(test_unit_version, _ruby_version = nil)
+        def self.applicable_to?(test_unit_version)
           Gem::Requirement.new('>= 2.5.1').satisfied_by?(test_unit_version)
         end