mocha 1.12.0 → 2.1.0

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
 
@@ -23,16 +23,16 @@ module Mocha
 
         # @private
         def self.included(mod)
-          mod.setup :mocha_setup, :before => :prepend
+          mod.setup :mocha_setup, before: :prepend
 
           mod.exception_handler(:handle_mocha_expectation_error)
 
-          mod.cleanup :after => :append do
+          mod.cleanup after: :append do
             assertion_counter = Integration::AssertionCounter.new(self)
             mocha_verify(assertion_counter)
           end
 
-          mod.teardown :mocha_teardown, :after => :append
+          mod.teardown :mocha_teardown, after: :append
         end
 
         private

data/lib/mocha/integration/test_unit.rb

@@ -1,49 +1,26 @@
 require 'mocha/debug'
-
 require 'mocha/detection/test_unit'
-
-require 'mocha/integration/test_unit/nothing'
-require 'mocha/integration/test_unit/ruby_version_185_and_below'
-require 'mocha/integration/test_unit/ruby_version_186_and_above'
-require 'mocha/integration/test_unit/gem_version_200'
-require 'mocha/integration/test_unit/gem_version_201_to_202'
-require 'mocha/integration/test_unit/gem_version_203_to_220'
-require 'mocha/integration/test_unit/gem_version_230_to_250'
 require 'mocha/integration/test_unit/adapter'
 
-require 'mocha/deprecation'
-
 module Mocha
   module Integration
     module TestUnit
       def self.activate
-        return false unless Detection::TestUnit.testcase
-        test_unit_version = Gem::Version.new(Detection::TestUnit.version)
-        ruby_version = Gem::Version.new(RUBY_VERSION.dup)
+        target = Detection::TestUnit.testcase
+        return false unless target
 
-        Debug.puts "Detected Ruby version: #{ruby_version}"
+        test_unit_version = Gem::Version.new(Detection::TestUnit.version)
         Debug.puts "Detected Test::Unit version: #{test_unit_version}"
 
-        integration_module = [
-          TestUnit::Adapter,
-          TestUnit::GemVersion230To250,
-          TestUnit::GemVersion203To220,
-          TestUnit::GemVersion201To202,
-          TestUnit::GemVersion200,
-          TestUnit::RubyVersion186AndAbove,
-          TestUnit::RubyVersion185AndBelow,
-          TestUnit::Nothing
-        ].detect { |m| m.applicable_to?(test_unit_version, ruby_version) }
+        unless TestUnit::Adapter.applicable_to?(test_unit_version)
+          raise 'Versions of test-unit earlier than v2.5.1 are not supported.'
+        end
 
-        unless ::Test::Unit::TestCase < integration_module
-          unless integration_module == TestUnit::Adapter
-            Deprecation.warning(
-              'Versions of test-unit earlier than v2.5.1 will not be supported in future versions of Mocha.'
-            )
-          end
-          Debug.puts "Applying #{integration_module.description}"
-          ::Test::Unit::TestCase.send(:include, integration_module)
+        unless target < TestUnit::Adapter
+          Debug.puts "Applying #{TestUnit::Adapter.description}"
+          target.send(:include, TestUnit::Adapter)
         end
+
         true
       end
     end

data/lib/mocha/invocation.rb

@@ -3,14 +3,12 @@ require 'mocha/raised_exception'
 require 'mocha/return_values'
 require 'mocha/thrown_object'
 require 'mocha/yield_parameters'
-require 'mocha/configuration'
-require 'mocha/deprecation'
 
 module Mocha
   class Invocation
     attr_reader :method_name, :block
 
-    def initialize(mock, method_name, *arguments, &block)
+    def initialize(mock, method_name, arguments = [], block = nil)
       @mock = mock
       @method_name = method_name
       @arguments = arguments
@@ -22,18 +20,8 @@ module Mocha
     def call(yield_parameters = YieldParameters.new, return_values = ReturnValues.new)
       yield_parameters.next_invocation.each do |yield_args|
         @yields << ParametersMatcher.new(yield_args)
-        if @block
-          @block.call(*yield_args)
-        else
-          raise LocalJumpError unless Mocha.configuration.reinstate_undocumented_behaviour_from_v1_9?
-          yield_args_description = ParametersMatcher.new(yield_args).mocha_inspect
-          Deprecation.warning(
-            "Stubbed method was instructed to yield #{yield_args_description}, but no block was given by invocation: #{call_description}.",
-            ' This will raise a LocalJumpError in the future.',
-            ' Use Expectation#with_block_given to constrain this expectation to match invocations supplying a block.',
-            ' And, if necessary, add another expectation to match invocations not supplying a block.'
-          )
-        end
+        raise LocalJumpError unless @block
+        @block.call(*yield_args)
       end
       return_values.next(self)
     end
@@ -55,7 +43,7 @@ module Mocha
     end
 
     def call_description
-      description = "#{@mock.mocha_inspect}.#{@method_name}#{ParametersMatcher.new(@arguments).mocha_inspect}"
+      description = "#{@mock.mocha_inspect}.#{@method_name}#{argument_description}"
       description << ' { ... }' unless @block.nil?
       description
     end
@@ -73,5 +61,13 @@ module Mocha
     def full_description
       "\n  - #{call_description} #{result_description}"
     end
+
+    private
+
+    def argument_description
+      signature = arguments.mocha_inspect
+      signature = signature.gsub(/^\[|\]$/, '')
+      "(#{signature})"
+    end
   end
 end

data/lib/mocha/minitest.rb

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

data/lib/mocha/mock.rb

@@ -1,4 +1,4 @@
-require 'mocha/singleton_class'
+require 'ruby2_keywords'
 require 'mocha/expectation'
 require 'mocha/expectation_list'
 require 'mocha/invocation'
@@ -8,7 +8,6 @@ require 'mocha/method_matcher'
 require 'mocha/parameters_matcher'
 require 'mocha/argument_iterator'
 require 'mocha/expectation_error_factory'
-require 'mocha/ruby_version'
 
 module Mocha
   # Traditional mock object.
@@ -109,6 +108,7 @@ module Mocha
     #   object.expects(:expected_method_one).returns(:result_one)
     #   object.expects(:expected_method_two).returns(:result_two)
     def expects(method_name_or_hash, backtrace = nil)
+      expectation = nil
       iterator = ArgumentIterator.new(method_name_or_hash)
       iterator.each do |*args|
         method_name = args.shift
@@ -117,6 +117,7 @@ module Mocha
         expectation.returns(args.shift) unless args.empty?
         @expectations.add(expectation)
       end
+      expectation
     end
 
     # Adds an expectation that the specified method may be called any number of times with any parameters.
@@ -145,6 +146,7 @@ module Mocha
     #   object.stubs(:stubbed_method_one).returns(:result_one)
     #   object.stubs(:stubbed_method_two).returns(:result_two)
     def stubs(method_name_or_hash, backtrace = nil)
+      expectation = nil
       iterator = ArgumentIterator.new(method_name_or_hash)
       iterator.each do |*args|
         method_name = args.shift
@@ -154,6 +156,7 @@ module Mocha
         expectation.returns(args.shift) unless args.empty?
         @expectations.add(expectation)
       end
+      expectation
     end
 
     # Removes the specified stubbed methods (added by calls to {#expects} or {#stubs}) and all expectations associated with them.
@@ -161,7 +164,7 @@ module Mocha
     # @param [Array<Symbol>] method_names names of methods to unstub.
     #
     # @example Invoking an unstubbed method causes error to be raised
-    #   object = mock('mock') do
+    #   object = mock('mock')
     #   object.stubs(:stubbed_method).returns(:result_one)
     #   object.stubbed_method # => :result_one
     #   object.unstub(:stubbed_method)
@@ -180,11 +183,11 @@ module Mocha
       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.
+    # Constrains the {Mock} instance so that it can only expect or stub methods to which +responder+ responds publicly. The constraint is only applied at method invocation time.
     #
-    # A +NoMethodError+ will be raised if the +responder+ does not +#respond_to?+ a method invocation (even if the method has been expected or stubbed).
+    # A +NoMethodError+ will be raised if the +responder+ does not publicly +#respond_to?+ the invoked method (even if the method has been expected or stubbed).
     #
-    # The {Mock} instance will delegate its +#respond_to?+ method to the +responder+.
+    # The {Mock} instance will delegate its +#respond_to?+ method to the +responder+. However, the +include_all+ parameter is not passed through, so only public methods on the +responder+ will be considered.
     #
     # Note that the methods on +responder+ are never actually invoked.
     #
@@ -234,11 +237,11 @@ module Mocha
       self
     end
 
-    # Constrains the {Mock} instance so that it can only expect or stub methods to which an instance of the +responder_class+ responds. The constraint is only applied at method invocation time. Note that the responder instance is instantiated using +Class#allocate+.
+    # Constrains the {Mock} instance so that it can only expect or stub methods to which an instance of the +responder_class+ responds publicly. The constraint is only applied at method invocation time. Note that the responder instance is instantiated using +Class#allocate+.
     #
-    # A +NoMethodError+ will be raised if the responder instance does not +#respond_to?+ a method invocation (even if the method has been expected or stubbed).
+    # A +NoMethodError+ will be raised if the responder instance does not publicly +#respond_to?+ the invoked method (even if the method has been expected or stubbed).
     #
-    # The {Mock} instance will delegate its +#respond_to?+ method to the responder instance.
+    # The {Mock} instance will delegate its +#respond_to?+ method to the responder instance. However, the +include_all+ parameter is not passed through, so only public methods on the +responder+  will be considered.
     #
     # Note that the methods on the responder instance are never actually invoked.
     #
@@ -306,10 +309,18 @@ module Mocha
     end
 
     # @private
-    def method_missing(symbol, *arguments, &block) # rubocop:disable Style/MethodMissingSuper
+    # rubocop:disable Style/MethodMissingSuper
+    def method_missing(symbol, *arguments, &block)
+      handle_method_call(symbol, arguments, block)
+    end
+    ruby2_keywords(:method_missing)
+    # rubocop:enable Style/MethodMissingSuper
+
+    # @private
+    def handle_method_call(symbol, arguments, block)
       check_expiry
       check_responder_responds_to(symbol)
-      invocation = Invocation.new(self, symbol, *arguments, &block)
+      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)
@@ -318,25 +329,14 @@ module Mocha
     end
 
     # @private
-    def respond_to_missing?(symbol, include_private = false)
+    def respond_to_missing?(symbol, _include_all)
       if @responder
-        if @responder.method(:respond_to?).arity > 1
-          @responder.respond_to?(symbol, include_private)
-        else
-          @responder.respond_to?(symbol)
-        end
+        @responder.respond_to?(symbol)
       else
         @everything_stubbed || all_expectations.matches_method?(symbol)
       end
     end
 
-    if PRE_RUBY_V19
-      # @private
-      def respond_to?(symbol, include_private = false)
-        respond_to_missing?(symbol, include_private)
-      end
-    end
-
     # @private
     def __verified__?(assertion_counter = nil)
       @expectations.verified?(assertion_counter)
@@ -387,14 +387,14 @@ module Mocha
     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
+      return unless @expired
+
+      sentences = [
+        "#{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.'
+      ]
+      raise StubbingError.new(sentences.join(' '), caller)
     end
   end
 end

data/lib/mocha/mockery.rb

@@ -1,4 +1,3 @@
-require 'mocha/ruby_version'
 require 'mocha/central'
 require 'mocha/mock'
 require 'mocha/names'
@@ -119,10 +118,9 @@ module Mocha
     end
 
     def on_stubbing(object, method)
-      method = PRE_RUBY_V19 ? method.to_s : method.to_sym
       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))
+        !(object.stubba_class.__method_exists__?(method, true) || object.respond_to?(method))
       end
       check(:stubbing_non_public_method, 'non-public method', signature_proc) do
         object.stubba_class.__method_exists__?(method, false)

data/lib/mocha/names.rb

@@ -37,7 +37,7 @@ module Mocha
     def mocha_inspect
       address = @mock.__id__ * 2
       address += 0x100000000 if address < 0
-      "#<Mock:0x#{format('%x', address)}>"
+      "#<Mock:0x#{format('%<address>x', address: address)}>"
     end
   end
 end

data/lib/mocha/parameter_matchers/base.rb

@@ -3,7 +3,7 @@ module Mocha
     # @abstract Subclass and implement +#matches?+ and +#mocha_inspect+ to define a custom matcher. Also add a suitably named instance method to {ParameterMatchers} to build an instance of the new matcher c.f. {#equals}.
     class Base
       # @private
-      def to_matcher
+      def to_matcher(_expectation = nil)
         self
       end
 

data/lib/mocha/parameter_matchers/equivalent_uri.rb

@@ -1,4 +1,3 @@
-require 'mocha/deprecation'
 require 'mocha/parameter_matchers/base'
 require 'uri'
 require 'cgi'
@@ -51,7 +50,7 @@ module Mocha
       # @private
       def explode(uri)
         query_hash = CGI.parse(uri.query || '')
-        URI::Generic::COMPONENT.inject({}) { |h, k| h.merge(k => uri.__send__(k)) }.merge(:query => query_hash)
+        URI::Generic::COMPONENT.inject({}) { |h, k| h.merge(k => uri.__send__(k)) }.merge(query: query_hash)
       end
     end
   end

data/lib/mocha/parameter_matchers/has_entry.rb

@@ -42,20 +42,10 @@ module Mocha
     #
     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
@@ -85,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_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

data/lib/mocha/parameter_matchers/instance_methods.rb

@@ -1,11 +1,12 @@
 require 'mocha/parameter_matchers/equals'
+require 'mocha/parameter_matchers/positional_or_keyword_hash'
 
 module Mocha
   module ParameterMatchers
     # @private
     module InstanceMethods
       # @private
-      def to_matcher
+      def to_matcher(_expectation = nil)
         Mocha::ParameterMatchers::Equals.new(self)
       end
     end
@@ -16,3 +17,11 @@ end
 class Object
   include Mocha::ParameterMatchers::InstanceMethods
 end
+
+# @private
+class Hash
+  # @private
+  def to_matcher(expectation = nil)
+    Mocha::ParameterMatchers::PositionalOrKeywordHash.new(self, expectation)
+  end
+end

data/lib/mocha/parameter_matchers/positional_or_keyword_hash.rb

@@ -0,0 +1,64 @@
+require 'mocha/configuration'
+require 'mocha/deprecation'
+require 'mocha/parameter_matchers/base'
+
+module Mocha
+  module ParameterMatchers
+    # @private
+    class PositionalOrKeywordHash < Base
+      def initialize(value, expectation)
+        @value = value
+        @expectation = expectation
+      end
+
+      def matches?(available_parameters)
+        parameter, is_last_parameter = extract_parameter(available_parameters)
+        return false unless parameter == @value
+
+        if is_last_parameter && !same_type_of_hash?(parameter, @value)
+          return false if Mocha.configuration.strict_keyword_argument_matching?
+
+          deprecation_warning(parameter, @value) if Mocha::RUBY_V27_PLUS
+        end
+
+        true
+      end
+
+      def mocha_inspect
+        @value.mocha_inspect
+      end
+
+      private
+
+      def extract_parameter(available_parameters)
+        [available_parameters.shift, available_parameters.empty?]
+      end
+
+      def same_type_of_hash?(actual, expected)
+        ruby2_keywords_hash?(actual) == ruby2_keywords_hash?(expected)
+      end
+
+      def deprecation_warning(actual, expected)
+        details1 = "Expectation #{expectation_definition} expected #{hash_type(expected)} (#{expected.mocha_inspect}),".squeeze(' ')
+        details2 = "but received #{hash_type(actual)} (#{actual.mocha_inspect})."
+        sentence1 = 'These will stop matching when strict keyword argument matching is enabled.'
+        sentence2 = 'See the documentation for Mocha::Configuration#strict_keyword_argument_matching=.'
+        Deprecation.warning([details1, details2, sentence1, sentence2].join(' '))
+      end
+
+      def hash_type(hash)
+        ruby2_keywords_hash?(hash) ? 'keyword arguments' : 'positional hash'
+      end
+
+      def ruby2_keywords_hash?(hash)
+        hash.is_a?(Hash) && ::Hash.ruby2_keywords_hash?(hash)
+      end
+
+      def expectation_definition
+        return nil unless @expectation
+
+        "defined at #{@expectation.definition_location}"
+      end
+    end
+  end
+end

data/lib/mocha/parameter_matchers.rb

@@ -13,6 +13,7 @@ require 'mocha/parameter_matchers/equals'
 require 'mocha/parameter_matchers/has_entry'
 require 'mocha/parameter_matchers/has_entries'
 require 'mocha/parameter_matchers/has_key'
+require 'mocha/parameter_matchers/has_keys'
 require 'mocha/parameter_matchers/has_value'
 require 'mocha/parameter_matchers/includes'
 require 'mocha/parameter_matchers/instance_of'

data/lib/mocha/parameters_matcher.rb

@@ -3,8 +3,9 @@ require 'mocha/parameter_matchers'
 
 module Mocha
   class ParametersMatcher
-    def initialize(expected_parameters = [ParameterMatchers::AnyParameters.new], &matching_block)
+    def initialize(expected_parameters = [ParameterMatchers::AnyParameters.new], expectation = nil, &matching_block)
       @expected_parameters = expected_parameters
+      @expectation = expectation
       @matching_block = matching_block
     end
 
@@ -23,12 +24,11 @@ module Mocha
     def mocha_inspect
       signature = matchers.mocha_inspect
       signature = signature.gsub(/^\[|\]$/, '')
-      signature = signature.gsub(/^\{|\}$/, '') if matchers.length == 1
       "(#{signature})"
     end
 
     def matchers
-      @expected_parameters.map(&:to_matcher)
+      @expected_parameters.map { |p| p.to_matcher(@expectation) }
     end
   end
 end

data/lib/mocha/ruby_version.rb

@@ -1,4 +1,3 @@
 module Mocha
-  PRE_RUBY_V19 = Gem::Version.new(RUBY_VERSION.dup) < Gem::Version.new('1.9')
-  RUBY_V2_PLUS = Gem::Version.new(RUBY_VERSION.dup) >= Gem::Version.new('2')
+  RUBY_V27_PLUS = Gem::Version.new(RUBY_VERSION.dup) >= Gem::Version.new('2.7')
 end