mocha 1.10.2 → 1.13.0

data/lib/mocha/inspect.rb

@@ -11,14 +11,16 @@ module Mocha
     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(', ')}}"
+      def mocha_inspect(wrapped = true)
+        unwrapped = collect { |key, value| "#{key.mocha_inspect} => #{value.mocha_inspect}" }.join(', ')
+        wrapped ? "{#{unwrapped}}" : unwrapped
       end
     end
 

data/lib/mocha/invocation.rb

@@ -8,7 +8,7 @@ require 'mocha/deprecation'
 
 module Mocha
   class Invocation
-    attr_reader :method_name
+    attr_reader :method_name, :block
 
     def initialize(mock, method_name, *arguments, &block)
       @mock = mock
@@ -27,10 +27,12 @@ module Mocha
         else
           raise LocalJumpError unless Mocha.configuration.reinstate_undocumented_behaviour_from_v1_9?
           yield_args_description = ParametersMatcher.new(yield_args).mocha_inspect
-          Deprecation.warning([
+          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.'
-          ].join(' '))
+            ' 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
       end
       return_values.next(self)
@@ -53,7 +55,9 @@ module Mocha
     end
 
     def call_description
-      "#{@mock.mocha_inspect}.#{@method_name}#{ParametersMatcher.new(@arguments).mocha_inspect}"
+      description = "#{@mock.mocha_inspect}.#{@method_name}#{ParametersMatcher.new(@arguments).mocha_inspect}"
+      description << ' { ... }' unless @block.nil?
+      description
     end
 
     def short_call_description

data/lib/mocha/mock.rb

@@ -275,6 +275,7 @@ module Mocha
       @everything_stubbed = false
       @responder = nil
       @unexpected_invocation = nil
+      @expired = false
     end
 
     # @private
@@ -305,26 +306,16 @@ module Mocha
     end
 
     # @private
-    # rubocop:disable Style/MethodMissingSuper,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
-    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
+    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)
-        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)
+        raise_unexpected_invocation_error(invocation, matching_expectation)
       end
     end
-    # rubocop:enable Style/MethodMissingSuper,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
 
     # @private
     def respond_to_missing?(symbol, include_private = false)
@@ -339,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
@@ -351,6 +342,11 @@ module Mocha
       @expectations.verified?(assertion_counter)
     end
 
+    # @private
+    def __expire__
+      @expired = true
+    end
+
     # @private
     def mocha_inspect
       @name.mocha_inspect
@@ -370,5 +366,35 @@ module Mocha
     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,13 +53,6 @@ module Mocha
         instance.teardown
       ensure
         @instances.pop
-        @instances = nil if instances.empty?
-      end
-
-      private
-
-      def instances
-        @instances ||= []
       end
     end
 
@@ -92,16 +86,15 @@ module Mocha
                     end
         raise ExpectationErrorFactory.build(message, backtrace)
       end
-      expectations.each do |e|
-        unless Mocha.configuration.stubbing_method_unnecessarily == :allow
-          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,27 +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
-      method_signature = "#{object.mocha_inspect}.#{method}"
-      check(:stubbing_non_existent_method, 'non-existent method', method_signature) do
+      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
-      check(:stubbing_non_public_method, 'non-public method', method_signature) do
+      check(:stubbing_non_public_method, 'non-public method', signature_proc) do
         object.stubba_class.__method_exists__?(method, false)
       end
-      check(:stubbing_method_on_nil, 'method on nil', method_signature) { object.nil? }
-      check(:stubbing_method_on_non_mock_object, 'method on non-mock object', method_signature)
-    end
-
-    def on_stubbing_method_unnecessarily(expectation)
-      check(:stubbing_method_unnecessarily, 'method unnecessarily', expectation.method_signature, expectation.backtrace)
+      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
@@ -150,9 +139,10 @@ module Mocha
 
     private
 
-    def check(action, description, method_signature, backtrace = caller)
+    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

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/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

data/lib/mocha/parameter_matchers/has_value.rb

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

data/lib/mocha/parameter_matchers/is_a.rb

@@ -21,11 +21,10 @@ module Mocha
     #   object.expects(:method_1).with(is_a(Integer))
     #   object.method_1('string')
     #   # error raised, because method_1 was not called with an Integer
-    # rubocop:disable Naming/PredicateName
-    def is_a(klass)
+    #
+    def is_a(klass) # rubocop:disable Naming/PredicateName
       IsA.new(klass)
     end
-    # rubocop:enable Naming/PredicateName
 
     # Parameter matcher which matches when actual parameter is a specific class.
     class IsA < Base

data/lib/mocha/parameter_matchers/not.rb

@@ -20,11 +20,10 @@ module Mocha
     #   object.expects(:method_1).with(Not(includes(1)))
     #   object.method_1([0, 1, 2, 3])
     #   # error raised, because method_1 was not called with object not including 1
-    # rubocop:disable Naming/MethodName
-    def Not(matcher)
+    #
+    def Not(matcher) # rubocop:disable Naming/MethodName
       Not.new(matcher)
     end
-    # rubocop:enable Naming/MethodName
 
     # Parameter matcher which inverts the logic of the specified matcher using a logical NOT operation.
     class Not < Base