mocha 1.8.0 → 1.13.0

data/lib/mocha/minitest.rb

@@ -1,3 +1,8 @@
 require 'mocha/integration/mini_test'
+require 'mocha/deprecation'
 
-Mocha::Integration::MiniTest.activate
+unless Mocha::Integration::MiniTest.activate
+  Mocha::Deprecation.warning(
+    "MiniTest must be loaded *before* `require 'mocha/minitest'`."
+  )
+end

data/lib/mocha/mock.rb

@@ -1,21 +1,27 @@
-require 'metaclass'
+require 'mocha/singleton_class'
 require 'mocha/expectation'
 require 'mocha/expectation_list'
+require 'mocha/invocation'
 require 'mocha/names'
 require 'mocha/receivers'
 require 'mocha/method_matcher'
 require 'mocha/parameters_matcher'
-require 'mocha/unexpected_invocation'
 require 'mocha/argument_iterator'
 require 'mocha/expectation_error_factory'
-require 'mocha/deprecation'
 require 'mocha/ruby_version'
 
 module Mocha
   # Traditional mock object.
   #
-  # All methods return an {Expectation} which can be further modified by
-  # methods on {Expectation}.
+  # {expects} and {stubs} return an {Expectation} which can be further modified
+  # by methods on {Expectation}.
+  #
+  # {responds_like} and {responds_like_instance_of} both return a {Mock}, and
+  # can therefore, be chained to the original creation methods in {API}.
+  # They force the mock to indicate what it is supposed to be mocking, thus
+  # making it a safer verifying mock. They check that the underlying +responder+
+  # will actually respond to the methods being stubbed, throwing a
+  # +NoMethodError+ upon invocation otherwise.
   #
   # Stubs and expectations are basically the same thing. A stub is just an
   # expectation of zero or more invocations. The {#stubs} method is syntactic
@@ -70,12 +76,12 @@ module Mocha
   class Mock
     # Adds an expectation that the specified method must be called exactly once with any parameters.
     #
-    # @param [Symbol,String] method_name name of expected method
-    # @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 {#expects} were called multiple times.
+    # @return [Expectation] last-built expectation which can be further modified by methods on {Expectation}.
     #
     # @overload def expects(method_name)
+    #   @param [Symbol,String] method_name name of expected method
     # @overload def expects(expected_methods_vs_return_values)
-    # @return [Expectation] last-built expectation which can be further modified by methods on {Expectation}.
+    #   @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 {#expects} were called multiple times.
     #
     # @example Expected method invoked once so no error raised
     #   object = mock()
@@ -115,12 +121,12 @@ module Mocha
 
     # Adds an expectation that the specified method may be called any number of times with any parameters.
     #
-    # @param [Symbol,String] method_name name of stubbed method
-    # @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 {#stubs} were called multiple times.
+    # @return [Expectation] last-built expectation which can be further modified by methods on {Expectation}.
     #
     # @overload def stubs(method_name)
+    #   @param [Symbol,String] method_name name of stubbed method
     # @overload def stubs(stubbed_methods_vs_return_values)
-    # @return [Expectation] last-built expectation which can be further modified by methods on {Expectation}.
+    #   @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 {#stubs} were called multiple times.
     #
     # @example No error raised however many times stubbed method is invoked
     #   object = mock()
@@ -150,9 +156,9 @@ module Mocha
       end
     end
 
-    # Removes the specified stubbed method (added by calls to {#expects} or {#stubs}) and all expectations associated with it.
+    # Removes the specified stubbed methods (added by calls to {#expects} or {#stubs}) and all expectations associated with them.
     #
-    # @param [Symbol] method_name name of method to unstub.
+    # @param [Array<Symbol>] method_names names of methods to unstub.
     #
     # @example Invoking an unstubbed method causes error to be raised
     #   object = mock('mock') do
@@ -160,8 +166,18 @@ module Mocha
     #   object.stubbed_method # => :result_one
     #   object.unstub(:stubbed_method)
     #   object.stubbed_method # => unexpected invocation: #<Mock:mock>.stubbed_method()
-    def unstub(method_name)
-      @expectations.remove_all_matching_method(method_name)
+    #
+    # @example Unstubbing multiple methods.
+    #   multiplier.unstub(:double, :triple)
+    #
+    #   # exactly equivalent to
+    #
+    #   multiplier.unstub(:double)
+    #   multiplier.unstub(:triple)
+    def unstub(*method_names)
+      method_names.each do |method_name|
+        @expectations.remove_all_matching_method(method_name)
+      end
     end
 
     # Constrains the {Mock} instance so that it can only expect or stub methods to which +responder+ responds. The constraint is only applied at method invocation time.
@@ -251,7 +267,7 @@ module Mocha
     end
 
     # @private
-    def initialize(mockery, name = nil, receiver = nil, &block)
+    def initialize(mockery, name = nil, receiver = nil)
       @mockery = mockery
       @name = name || DefaultName.new(self)
       @receiver = receiver || DefaultReceiver.new(self)
@@ -259,9 +275,7 @@ module Mocha
       @everything_stubbed = false
       @responder = nil
       @unexpected_invocation = nil
-      return unless block
-      Deprecation.warning('Passing a block is deprecated. Use Object#tap or define stubs/expectations with an explicit receiver instead.')
-      instance_eval(&block)
+      @expired = false
     end
 
     # @private
@@ -271,6 +285,8 @@ module Mocha
 
     alias_method :__stubs__, :stubs
 
+    alias_method :__singleton_class__, :singleton_class
+
     alias_method :quacks_like, :responds_like
     alias_method :quacks_like_instance_of, :responds_like_instance_of
 
@@ -290,26 +306,16 @@ module Mocha
     end
 
     # @private
-    # rubocop:disable Style/MethodMissingSuper
-    def method_missing(symbol, *arguments, &block)
-      if @responder && !@responder.respond_to?(symbol)
-        raise NoMethodError, "undefined method `#{symbol}' for #{mocha_inspect} which responds like #{@responder.mocha_inspect}"
-      end
-      if (matching_expectation_allowing_invocation = all_expectations.match_allowing_invocation(symbol, *arguments))
-        matching_expectation_allowing_invocation.invoke(&block)
-      elsif (matching_expectation = all_expectations.match(symbol, *arguments)) || (!matching_expectation && !@everything_stubbed)
-        if @unexpected_invocation.nil?
-          @unexpected_invocation = UnexpectedInvocation.new(self, symbol, *arguments)
-          matching_expectation.invoke(&block) if matching_expectation
-          message = @unexpected_invocation.full_description
-          message << @mockery.mocha_inspect
-        else
-          message = @unexpected_invocation.short_description
-        end
-        raise ExpectationErrorFactory.build(message, caller)
+    def method_missing(symbol, *arguments, &block) # rubocop:disable Style/MethodMissingSuper
+      check_expiry
+      check_responder_responds_to(symbol)
+      invocation = Invocation.new(self, symbol, *arguments, &block)
+      if (matching_expectation_allowing_invocation = all_expectations.match_allowing_invocation(invocation))
+        matching_expectation_allowing_invocation.invoke(invocation)
+      elsif (matching_expectation = all_expectations.match(invocation)) || (!matching_expectation && !@everything_stubbed)
+        raise_unexpected_invocation_error(invocation, matching_expectation)
       end
     end
-    # rubocop:enable Style/MethodMissingSuper
 
     # @private
     def respond_to_missing?(symbol, include_private = false)
@@ -324,8 +330,8 @@ module Mocha
       end
     end
 
-    # @private
     if PRE_RUBY_V19
+      # @private
       def respond_to?(symbol, include_private = false)
         respond_to_missing?(symbol, include_private)
       end
@@ -336,6 +342,11 @@ module Mocha
       @expectations.verified?(assertion_counter)
     end
 
+    # @private
+    def __expire__
+      @expired = true
+    end
+
     # @private
     def mocha_inspect
       @name.mocha_inspect
@@ -348,12 +359,42 @@ module Mocha
 
     # @private
     def ensure_method_not_already_defined(method_name)
-      __metaclass__.send(:undef_method, method_name) if __metaclass__.method_defined?(method_name) || __metaclass__.private_method_defined?(method_name)
+      __singleton_class__.send(:undef_method, method_name) if __singleton_class__.method_defined?(method_name) || __singleton_class__.private_method_defined?(method_name)
     end
 
     # @private
     def any_expectations?
       @expectations.any?
     end
+
+    private
+
+    def raise_unexpected_invocation_error(invocation, matching_expectation)
+      if @unexpected_invocation.nil?
+        @unexpected_invocation = invocation
+        matching_expectation.invoke(invocation) if matching_expectation
+        message = "#{@unexpected_invocation.call_description}\n#{@mockery.mocha_inspect}"
+      else
+        message = @unexpected_invocation.short_call_description
+      end
+      raise ExpectationErrorFactory.build("unexpected invocation: #{message}", caller)
+    end
+
+    def check_responder_responds_to(symbol)
+      if @responder && !@responder.respond_to?(symbol) # rubocop:disable Style/GuardClause
+        raise NoMethodError, "undefined method `#{symbol}' for #{mocha_inspect} which responds like #{@responder.mocha_inspect}"
+      end
+    end
+
+    def check_expiry
+      if @expired # rubocop:disable Style/GuardClause
+        Deprecation.warning(
+          "#{mocha_inspect} was instantiated in one test but it is receiving invocations within another test.",
+          ' This can lead to unintended interactions between tests and hence unexpected test failures.',
+          ' Ensure that every test correctly cleans up any state that it introduces.',
+          ' A Mocha::StubbingError will be raised in this scenario in the future.'
+        )
+      end
+    end
   end
 end

data/lib/mocha/mockery.rb

@@ -35,12 +35,13 @@ module Mocha
 
     class << self
       def instance
-        instances.last || Null.new
+        @instances.last || Null.new
       end
 
       def setup
+        @instances ||= []
         mockery = new
-        mockery.logger = instance.logger unless instances.empty?
+        mockery.logger = instance.logger unless @instances.empty?
         @instances.push(mockery)
       end
 
@@ -52,30 +53,23 @@ module Mocha
         instance.teardown
       ensure
         @instances.pop
-        @instances = nil if instances.empty?
-      end
-
-      private
-
-      def instances
-        @instances ||= []
       end
     end
 
-    def named_mock(name, &block)
-      add_mock(Mock.new(self, Name.new(name), &block))
+    def named_mock(name)
+      add_mock(Mock.new(self, Name.new(name)))
     end
 
-    def unnamed_mock(&block)
-      add_mock(Mock.new(self, &block))
+    def unnamed_mock
+      add_mock(Mock.new(self))
     end
 
-    def mock_impersonating(object, &block)
-      add_mock(Mock.new(self, ImpersonatingName.new(object), ObjectReceiver.new(object), &block))
+    def mock_impersonating(object)
+      add_mock(Mock.new(self, ImpersonatingName.new(object), ObjectReceiver.new(object)))
     end
 
-    def mock_impersonating_any_instance_of(klass, &block)
-      add_mock(Mock.new(self, ImpersonatingAnyInstanceName.new(klass), AnyInstanceReceiver.new(klass), &block))
+    def mock_impersonating_any_instance_of(klass)
+      add_mock(Mock.new(self, ImpersonatingAnyInstanceName.new(klass), AnyInstanceReceiver.new(klass)))
     end
 
     def new_state_machine(name)
@@ -92,16 +86,15 @@ module Mocha
                     end
         raise ExpectationErrorFactory.build(message, backtrace)
       end
-      expectations.each do |e|
-        unless Mocha::Configuration.allow?(:stubbing_method_unnecessarily)
-          next if e.used?
-          on_stubbing_method_unnecessarily(e)
-        end
+      expectations.reject(&:used?).each do |expectation|
+        signature_proc = lambda { expectation.method_signature }
+        check(:stubbing_method_unnecessarily, 'method unnecessarily', signature_proc, expectation.backtrace)
       end
     end
 
     def teardown
       stubba.unstub_all
+      mocks.each(&:__expire__)
       reset
     end
 
@@ -119,71 +112,23 @@ module Mocha
 
     def mocha_inspect
       message = ''
-      message << "unsatisfied expectations:\n- #{unsatisfied_expectations.map(&:mocha_inspect).join("\n- ")}\n" unless unsatisfied_expectations.empty?
-      message << "satisfied expectations:\n- #{satisfied_expectations.map(&:mocha_inspect).join("\n- ")}\n" unless satisfied_expectations.empty?
-      message << "states:\n- #{state_machines.map(&:mocha_inspect).join("\n- ")}" unless state_machines.empty?
+      message << "unsatisfied expectations:\n- #{unsatisfied_expectations.map(&:mocha_inspect).join("\n- ")}\n" if unsatisfied_expectations.any?
+      message << "satisfied expectations:\n- #{satisfied_expectations.map(&:mocha_inspect).join("\n- ")}\n" if satisfied_expectations.any?
+      message << "states:\n- #{state_machines.map(&:mocha_inspect).join("\n- ")}\n" if state_machines.any?
       message
     end
 
     def on_stubbing(object, method)
       method = PRE_RUBY_V19 ? method.to_s : method.to_sym
-      unless Mocha::Configuration.allow?(:stubbing_non_existent_method)
-        unless object.method_exists?(method, true)
-          on_stubbing_non_existent_method(object, method)
-        end
-      end
-      unless Mocha::Configuration.allow?(:stubbing_non_public_method)
-        if object.method_exists?(method, false)
-          on_stubbing_non_public_method(object, method)
-        end
-      end
-      unless Mocha::Configuration.allow?(:stubbing_method_on_nil)
-        if object.nil?
-          on_stubbing_method_on_nil(object, method)
-        end
-      end
-      return if Mocha::Configuration.allow?(:stubbing_method_on_non_mock_object)
-      on_stubbing_method_on_non_mock_object(object, method)
-    end
-
-    def on_stubbing_non_existent_method(object, method)
-      if Mocha::Configuration.prevent?(:stubbing_non_existent_method)
-        raise StubbingError.new("stubbing non-existent method: #{object.mocha_inspect}.#{method}", caller)
-      end
-      return unless Mocha::Configuration.warn_when?(:stubbing_non_existent_method)
-      logger.warn "stubbing non-existent method: #{object.mocha_inspect}.#{method}"
-    end
-
-    def on_stubbing_non_public_method(object, method)
-      if Mocha::Configuration.prevent?(:stubbing_non_public_method)
-        raise StubbingError.new("stubbing non-public method: #{object.mocha_inspect}.#{method}", caller)
-      end
-      return unless Mocha::Configuration.warn_when?(:stubbing_non_public_method)
-      logger.warn "stubbing non-public method: #{object.mocha_inspect}.#{method}"
-    end
-
-    def on_stubbing_method_on_nil(object, method)
-      if Mocha::Configuration.prevent?(:stubbing_method_on_nil)
-        raise StubbingError.new("stubbing method on nil: #{object.mocha_inspect}.#{method}", caller)
-      end
-      return unless Mocha::Configuration.warn_when?(:stubbing_method_on_nil)
-      logger.warn "stubbing method on nil: #{object.mocha_inspect}.#{method}"
-    end
-
-    def on_stubbing_method_on_non_mock_object(object, method)
-      if Mocha::Configuration.prevent?(:stubbing_method_on_non_mock_object)
-        raise StubbingError.new("stubbing method on non-mock object: #{object.mocha_inspect}.#{method}", caller)
+      signature_proc = lambda { "#{object.mocha_inspect}.#{method}" }
+      check(:stubbing_non_existent_method, 'non-existent method', signature_proc) do
+        !(object.stubba_class.__method_exists__?(method, true) || object.respond_to?(method.to_sym))
       end
-      return unless Mocha::Configuration.warn_when?(:stubbing_method_on_non_mock_object)
-      logger.warn "stubbing method on non-mock object: #{object.mocha_inspect}.#{method}"
-    end
-
-    def on_stubbing_method_unnecessarily(expectation)
-      if Mocha::Configuration.prevent?(:stubbing_method_unnecessarily)
-        raise StubbingError.new("stubbing method unnecessarily: #{expectation.method_signature}", expectation.backtrace)
+      check(:stubbing_non_public_method, 'non-public method', signature_proc) do
+        object.stubba_class.__method_exists__?(method, false)
       end
-      return unless Mocha::Configuration.warn_when?(:stubbing_method_unnecessarily)
-      logger.warn "stubbing method unnecessarily: #{expectation.method_signature}"
+      check(:stubbing_method_on_nil, 'method on nil', signature_proc) { object.nil? }
+      check(:stubbing_method_on_non_mock_object, 'method on non-mock object', signature_proc)
     end
 
     attr_writer :logger
@@ -194,6 +139,15 @@ module Mocha
 
     private
 
+    def check(action, description, signature_proc, backtrace = caller)
+      treatment = Mocha.configuration.send(action)
+      return if (treatment == :allow) || (block_given? && !yield)
+      method_signature = signature_proc.call
+      message = "stubbing #{description}: #{method_signature}"
+      raise StubbingError.new(message, backtrace) if treatment == :prevent
+      logger.warn(message) if treatment == :warn
+    end
+
     def expectations
       mocks.map { |mock| mock.__expectations__.to_a }.flatten
     end

data/lib/mocha/names.rb

@@ -21,7 +21,7 @@ module Mocha
 
   class Name
     def initialize(name)
-      @name = name
+      @name = name.to_s
     end
 
     def mocha_inspect

data/lib/mocha/object_methods.rb

@@ -35,17 +35,22 @@ module Mocha
       self
     end
 
+    # @private
+    def stubba_class
+      singleton_class
+    end
+
     # Adds an expectation that the specified method must be called exactly once with any parameters.
     #
     # The original implementation of the method is replaced during the test and then restored at the end of the test. The temporary replacement method has the same visibility as the original method.
     #
-    # @param [Symbol,String] method_name name of expected method
-    # @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 {#expects} were called multiple times.
+    # @return [Expectation] last-built expectation which can be further modified by methods on {Expectation}.
+    # @raise [StubbingError] if attempting to stub method which is not allowed.
     #
     # @overload def expects(method_name)
+    #   @param [Symbol,String] method_name name of expected method
     # @overload def expects(expected_methods_vs_return_values)
-    # @return [Expectation] last-built expectation which can be further modified by methods on {Expectation}.
-    # @raise [StubbingError] if attempting to stub method which is not allowed.
+    #   @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 {#expects} were called multiple times.
     #
     # @example Setting up an expectation on a non-mock object.
     #   product = Product.new
@@ -88,13 +93,13 @@ module Mocha
     #
     # The original implementation of the method is replaced during the test and then restored at the end of the test. The temporary replacement method has the same visibility as the original method.
     #
-    # @param [Symbol,String] method_name name of stubbed method
-    # @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 {#stubs} were called multiple times.
+    # @return [Expectation] last-built expectation which can be further modified by methods on {Expectation}.
+    # @raise [StubbingError] if attempting to stub method which is not allowed.
     #
     # @overload def stubs(method_name)
+    #   @param [Symbol,String] method_name name of stubbed method
     # @overload def stubs(stubbed_methods_vs_return_values)
-    # @return [Expectation] last-built expectation which can be further modified by methods on {Expectation}.
-    # @raise [StubbingError] if attempting to stub method which is not allowed.
+    #   @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 {#stubs} were called multiple times.
     #
     # @example Setting up a stubbed methods on a non-mock object.
     #   product = Product.new
@@ -160,16 +165,5 @@ module Mocha
         mockery.stubba.unstub(method)
       end
     end
-
-    # @private
-    def method_exists?(method, include_public_methods = true)
-      if include_public_methods
-        return true if public_methods(true).include?(method)
-        return true if respond_to?(method.to_sym)
-      end
-      return true if protected_methods(true).include?(method)
-      return true if private_methods(true).include?(method)
-      false
-    end
   end
 end

data/lib/mocha/parameter_matchers/all_of.rb

@@ -4,7 +4,7 @@ module Mocha
   module ParameterMatchers
     # Matches if all +matchers+ match.
     #
-    # @param [*Array<Base>] parameter_matchers parameter matchers.
+    # @param [*Array<Base>] matchers parameter matchers.
     # @return [AllOf] parameter matcher.
     #
     # @see Expectation#with

data/lib/mocha/parameter_matchers/any_of.rb

@@ -4,7 +4,7 @@ module Mocha
   module ParameterMatchers
     # Matches if any +matchers+ match.
     #
-    # @param [*Array<Base>] parameter_matchers parameter matchers.
+    # @param [*Array<Base>] matchers parameter matchers.
     # @return [AnyOf] parameter matcher.
     #
     # @see Expectation#with

data/lib/mocha/parameter_matchers/equivalent_uri.rb

@@ -27,15 +27,6 @@ module Mocha
       EquivalentUri.new(uri)
     end
 
-    # @deprecated Use {#equivalent_uri} instead.
-    # rubocop:disable Naming/PredicateName
-    def has_equivalent_query_string(uri)
-      Mocha::Deprecation.warning('`has_equivalent_query_string` is deprecated. Please use `equivalent_uri` instead.')
-
-      equivalent_uri(uri)
-    end
-    # rubocop:enable Naming/PredicateName
-
     # Parameter matcher which matches URIs with equivalent query strings.
     class EquivalentUri < Base
       # @private

data/lib/mocha/parameter_matchers/has_entries.rb

@@ -22,11 +22,10 @@ module Mocha
     #   object.expects(:method_1).with(has_entries('key_1' => 1, 'key_2' => 2))
     #   object.method_1('key_1' => 1, 'key_2' => 99)
     #   # error raised, because method_1 was not called with Hash containing entries: 'key_1' => 1, 'key_2' => 2
-    # rubocop:disable Naming/PredicateName
-    def has_entries(entries)
+    #
+    def has_entries(entries) # rubocop:disable Naming/PredicateName
       HasEntries.new(entries)
     end
-    # rubocop:enable Naming/PredicateName
 
     # Parameter matcher which matches when actual parameter contains all expected +Hash+ entries.
     class HasEntries < Base

data/lib/mocha/parameter_matchers/has_entry.rb

@@ -39,23 +39,13 @@ module Mocha
     #   object.expects(:method_1).with(has_entry('key_1' => 1))
     #   object.method_1('key_1' => 2, 'key_2' => 1)
     #   # error raised, because method_1 was not called with Hash containing entry: 'key_1' => 1
-    # rubocop:disable Naming/PredicateName
-    def has_entry(*options)
+    #
+    def has_entry(*options) # rubocop:disable Naming/PredicateName
       case options.length
+      when 0
+        raise ArgumentError, 'No arguments. Expecting at least one.'
       when 1
-        case options[0]
-        when Hash
-          case options[0].length
-          when 0
-            raise ArgumentError, 'Argument has no entries.'
-          when 1
-            key, value = options[0].first
-          else
-            raise ArgumentError, 'Argument has multiple entries. Use Mocha::ParameterMatchers#has_entries instead.'
-          end
-        else
-          raise ArgumentError, 'Argument is not a Hash.'
-        end
+        key, value = parse_option(options[0])
       when 2
         key, value = options
       else
@@ -63,7 +53,6 @@ module Mocha
       end
       HasEntry.new(key, value)
     end
-    # rubocop:enable Naming/PredicateName
 
     # Parameter matcher which matches when actual parameter contains expected +Hash+ entry.
     class HasEntry < Base
@@ -86,5 +75,24 @@ module Mocha
         "has_entry(#{@key.mocha_inspect} => #{@value.mocha_inspect})"
       end
     end
+
+    private
+
+    # @private
+    def parse_option(option)
+      case option
+      when Hash
+        case option.length
+        when 0
+          raise ArgumentError, 'Argument has no entries.'
+        when 1
+          option.first
+        else
+          raise ArgumentError, 'Argument has multiple entries. Use Mocha::ParameterMatchers#has_entries instead.'
+        end
+      else
+        raise ArgumentError, 'Argument is not a Hash.'
+      end
+    end
   end
 end

data/lib/mocha/parameter_matchers/has_key.rb

@@ -20,11 +20,10 @@ module Mocha
     #   object.expects(:method_1).with(has_key('key_1'))
     #   object.method_1('key_2' => 2)
     #   # error raised, because method_1 was not called with Hash containing key: 'key_1'
-    # rubocop:disable Naming/PredicateName
-    def has_key(key)
+    #
+    def has_key(key) # rubocop:disable Naming/PredicateName
       HasKey.new(key)
     end
-    # rubocop:enable Naming/PredicateName
 
     # Parameter matcher which matches when actual parameter contains +Hash+ entry with expected key.
     class HasKey < Base

data/lib/mocha/parameter_matchers/has_keys.rb

@@ -0,0 +1,53 @@
+require 'mocha/parameter_matchers/base'
+
+module Mocha
+  module ParameterMatchers
+    # Matches +Hash+ containing +keys+.
+    #
+    # @param [*Array<Object>] keys expected keys.
+    # @return [HasKeys] parameter matcher.
+    #
+    # @see Expectation#with
+    #
+    # @example Actual parameter contains entry with expected keys.
+    #   object = mock()
+    #   object.expects(:method_1).with(has_keys(:key_1, :key_2))
+    #   object.method_1(:key_1 => 1, :key_2 => 2, :key_3 => 3)
+    #   # no error raised
+    #
+    # @example Actual parameter does not contain all expected keys.
+    #   object = mock()
+    #   object.expects(:method_1).with(has_keys(:key_1, :key_2))
+    #   object.method_1(:key_2 => 2)
+    #   # error raised, because method_1 was not called with Hash containing key: :key_1
+    #
+    def has_keys(*keys) # rubocop:disable Naming/PredicateName
+      HasKeys.new(*keys)
+    end
+
+    # Parameter matcher which matches when actual parameter contains +Hash+ with all expected keys.
+    class HasKeys < Base
+      # @private
+      def initialize(*keys)
+        raise ArgumentError, 'No arguments. Expecting at least one.' if keys.empty?
+
+        @keys = keys
+      end
+
+      # @private
+      def matches?(available_parameters)
+        parameter = available_parameters.shift
+        return false unless parameter.respond_to?(:keys)
+
+        @keys.map(&:to_matcher).all? do |matcher|
+          parameter.keys.any? { |key| matcher.matches?([key]) }
+        end
+      end
+
+      # @private
+      def mocha_inspect
+        "has_keys(#{@keys.mocha_inspect(false)})"
+      end
+    end
+  end
+end