mocha 1.12.0 → 2.1.0

data/lib/mocha/api.rb

@@ -1,3 +1,4 @@
+require 'mocha/ruby_version'
 require 'mocha/parameter_matchers'
 require 'mocha/hooks'
 require 'mocha/mockery'
@@ -51,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 = {})
@@ -66,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)
@@ -98,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
@@ -111,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.
     #
@@ -145,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 = {})
@@ -159,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.
     #
@@ -199,11 +140,22 @@ module Mocha
     # @example Ensure methods on egg are invoked in correct order.
     #   breakfast = sequence('breakfast')
     #
-    #   egg = mock('egg') do
-    #     expects(:crack).in_sequence(breakfast)
-    #     expects(:fry).in_sequence(breakfast)
-    #     expects(:eat).in_sequence(breakfast)
-    #   end
+    #   egg = mock('egg')
+    #   egg.expects(:crack).in_sequence(breakfast)
+    #   egg.expects(:fry).in_sequence(breakfast)
+    #   egg.expects(:eat).in_sequence(breakfast)
+    #
+    # @example Ensure methods across multiple objects are invoked in correct order.
+    #   sequence = sequence(:task_order)
+    #
+    #   task_one = mock("task_one")
+    #   task_two = mock("task_two")
+    #
+    #   task_one.expects(:execute).in_sequence(sequence)
+    #   task_two.expects(:execute).in_sequence(sequence)
+    #
+    #   task_one.execute
+    #   task_two.execute
     def sequence(name)
       Sequence.new(name)
     end
@@ -226,14 +178,13 @@ module Mocha
     # @example Constrain expected invocations to occur in particular states.
     #   power = states('power').starts_as('off')
     #
-    #   radio = mock('radio') do
-    #     expects(:switch_on).then(power.is('on'))
-    #     expects(:select_channel).with('BBC Radio 4').when(power.is('on'))
-    #     expects(:adjust_volume).with(+5).when(power.is('on'))
-    #     expects(:select_channel).with('BBC World Service').when(power.is('on'))
-    #     expects(:adjust_volume).with(-5).when(power.is('on'))
-    #     expects(:switch_off).then(power.is('off'))
-    #   end
+    #   radio = mock('radio')
+    #   radio.expects(:switch_on).then(power.is('on'))
+    #   radio.expects(:select_channel).with('BBC Radio 4').when(power.is('on'))
+    #   radio.expects(:adjust_volume).with(+5).when(power.is('on'))
+    #   radio.expects(:select_channel).with('BBC World Service').when(power.is('on'))
+    #   radio.expects(:adjust_volume).with(-5).when(power.is('on'))
+    #   radio.expects(:switch_off).then(power.is('off'))
     def states(name)
       Mockery.instance.new_state_machine(name)
     end

data/lib/mocha/backtrace_filter.rb

@@ -3,11 +3,11 @@ module Mocha
     LIB_DIRECTORY = File.expand_path(File.join(File.dirname(__FILE__), '..')) + File::SEPARATOR
 
     def initialize(lib_directory = LIB_DIRECTORY)
-      @path_pattern = Regexp.new(lib_directory)
+      @lib_directory = lib_directory
     end
 
     def filtered(backtrace)
-      backtrace.reject { |location| @path_pattern.match(File.expand_path(location)) }
+      backtrace.reject { |location| File.expand_path(location).start_with?(@lib_directory) }
     end
   end
 end

data/lib/mocha/class_methods.rb

@@ -26,8 +26,8 @@ module Mocha
         @stubba_object
       end
 
-      def respond_to?(method)
-        @stubba_object.allocate.respond_to?(method.to_sym)
+      def respond_to?(symbol, include_all = false)
+        @stubba_object.allocate.respond_to?(symbol.to_sym, include_all)
       end
 
       attr_reader :stubba_object

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.
   #
@@ -37,13 +39,13 @@ module Mocha
   class Configuration
     # @private
     DEFAULTS = {
-      :stubbing_method_unnecessarily => :allow,
-      :stubbing_method_on_non_mock_object => :allow,
-      :stubbing_non_existent_method => :allow,
-      :stubbing_non_public_method => :allow,
-      :stubbing_method_on_nil => :prevent,
-      :display_matching_invocations_on_failure => false,
-      :reinstate_undocumented_behaviour_from_v1_9 => true
+      stubbing_method_unnecessarily: :allow,
+      stubbing_method_on_non_mock_object: :allow,
+      stubbing_non_existent_method: :allow,
+      stubbing_non_public_method: :allow,
+      stubbing_method_on_nil: :prevent,
+      display_matching_invocations_on_failure: false,
+      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 misleading passing tests 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 misleading passing tests 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/debug.rb

@@ -1,12 +1,9 @@
 module Mocha
   module Debug
-    OPTIONS = (ENV['MOCHA_OPTIONS'] || '').split(',').inject({}) do |hash, key|
-      hash[key] = true
-      hash
-    end.freeze
+    OPTIONS = (ENV['MOCHA_OPTIONS'] || '').split(',').freeze
 
     def self.puts(message)
-      warn(message) if OPTIONS['debug']
+      warn(message) if OPTIONS.include?('debug')
     end
   end
 end

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.
     #
@@ -625,7 +674,7 @@ module Mocha
     def inspect
       address = __id__ * 2
       address += 0x100000000 if address < 0
-      "#<Expectation:0x#{format('%x', address)} #{mocha_inspect} >"
+      "#<Expectation:0x#{format('%<address>x', address: address)} #{mocha_inspect} >"
     end
 
     # @private
@@ -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

@@ -6,19 +6,21 @@ module Mocha
       def mocha_inspect
         address = __id__ * 2
         address += 0x100000000 if address < 0
-        inspect =~ /#</ ? "#<#{self.class}:0x#{Kernel.format('%x', address)}>" : inspect
+        inspect =~ /#</ ? "#<#{self.class}:0x#{Kernel.format('%<address>x', address: address)}>" : inspect
       end
     end
 
     module ArrayMethods
-      def mocha_inspect
-        "[#{collect(&:mocha_inspect).join(', ')}]"
+      def mocha_inspect(wrapped = true)
+        unwrapped = collect(&:mocha_inspect).join(', ')
+        wrapped ? "[#{unwrapped}]" : unwrapped
       end
     end
 
     module HashMethods
       def mocha_inspect
-        "{#{collect { |key, value| "#{key.mocha_inspect} => #{value.mocha_inspect}" }.join(', ')}}"
+        unwrapped = collect { |key, value| "#{key.mocha_inspect} => #{value.mocha_inspect}" }.join(', ')
+        Hash.ruby2_keywords_hash?(self) ? unwrapped : "{#{unwrapped}}"
       end
     end
 

data/lib/mocha/instance_method.rb

@@ -8,10 +8,6 @@ module Mocha
       stubbee
     end
 
-    def method_body(method)
-      PRE_RUBY_V19 ? proc { |*args, &block| method.call(*args, &block) } : method
-    end
-
     def stubbee_method(method_name)
       stubbee._method(method_name)
     end

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

@@ -23,7 +23,7 @@ module Mocha
 
         # @private
         def self.included(_mod)
-          Mocha::ExpectationErrorFactory.exception_class = ::MiniTest::Assertion
+          Mocha::ExpectationErrorFactory.exception_class = ::Minitest::Assertion
         end
 
         # @private

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