mocha 1.8.0 → 1.11.0

data/lib/mocha/integration/mini_test.rb

@@ -14,6 +14,8 @@ 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
@@ -39,6 +41,11 @@ module Mocha
 
         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)
         end

data/lib/mocha/integration/test_unit.rb

@@ -11,6 +11,8 @@ 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
@@ -34,6 +36,11 @@ module Mocha
         ].detect { |m| m.applicable_to?(test_unit_version, ruby_version) }
 
         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)
         end

data/lib/mocha/invocation.rb

@@ -0,0 +1,77 @@
+require 'mocha/parameters_matcher'
+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)
+      @mock = mock
+      @method_name = method_name
+      @arguments = arguments
+      @block = block
+      @yields = []
+      @result = nil
+    end
+
+    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
+      end
+      return_values.next(self)
+    end
+
+    def returned(value)
+      @result = value
+    end
+
+    def raised(exception)
+      @result = RaisedException.new(exception)
+    end
+
+    def threw(tag, value)
+      @result = ThrownObject.new(tag, value)
+    end
+
+    def arguments
+      @arguments.dup
+    end
+
+    def call_description
+      description = "#{@mock.mocha_inspect}.#{@method_name}#{ParametersMatcher.new(@arguments).mocha_inspect}"
+      description << ' { ... }' unless @block.nil?
+      description
+    end
+
+    def short_call_description
+      "#{@method_name}(#{@arguments.join(', ')})"
+    end
+
+    def result_description
+      desc = "# => #{@result.mocha_inspect}"
+      desc << " after yielding #{@yields.map(&:mocha_inspect).join(', then ')}" if @yields.any?
+      desc
+    end
+
+    def full_description
+      "\n  - #{call_description} #{result_description}"
+    end
+  end
+end

data/lib/mocha/macos_version.rb

@@ -0,0 +1,5 @@
+module Mocha
+  MACOS = /darwin/.match(RUBY_PLATFORM)
+  MACOS_VERSION = MACOS && /darwin(\d+)/.match(RUBY_PLATFORM)[1].to_i
+  MACOS_MOJAVE_VERSION = 18
+end

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,6 @@ 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)
     end
 
     # @private
@@ -271,6 +284,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 +305,26 @@ module Mocha
     end
 
     # @private
-    # rubocop:disable Style/MethodMissingSuper
+    # 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
-      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)
+      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 = UnexpectedInvocation.new(self, symbol, *arguments)
-          matching_expectation.invoke(&block) if matching_expectation
-          message = @unexpected_invocation.full_description
-          message << @mockery.mocha_inspect
+          @unexpected_invocation = invocation
+          matching_expectation.invoke(invocation) if matching_expectation
+          message = "#{@unexpected_invocation.call_description}\n#{@mockery.mocha_inspect}"
         else
-          message = @unexpected_invocation.short_description
+          message = @unexpected_invocation.short_call_description
         end
-        raise ExpectationErrorFactory.build(message, caller)
+        raise ExpectationErrorFactory.build("unexpected invocation: #{message}", caller)
       end
     end
-    # rubocop:enable Style/MethodMissingSuper
+    # rubocop:enable Style/MethodMissingSuper,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
 
     # @private
     def respond_to_missing?(symbol, include_private = false)
@@ -348,7 +363,7 @@ 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

data/lib/mocha/mockery.rb

@@ -62,20 +62,20 @@ module Mocha
       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)
@@ -93,7 +93,7 @@ module Mocha
         raise ExpectationErrorFactory.build(message, backtrace)
       end
       expectations.each do |e|
-        unless Mocha::Configuration.allow?(:stubbing_method_unnecessarily)
+        unless Mocha.configuration.stubbing_method_unnecessarily == :allow
           next if e.used?
           on_stubbing_method_unnecessarily(e)
         end
@@ -127,63 +127,19 @@ module Mocha
 
     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
+      method_signature = "#{object.mocha_inspect}.#{method}"
+      check(:stubbing_non_existent_method, 'non-existent method', method_signature) do
+        !(object.stubba_class.__method_exists__?(method, true) || object.respond_to?(method.to_sym))
       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)
+      check(:stubbing_non_public_method, 'non-public method', method_signature) do
+        object.stubba_class.__method_exists__?(method, false)
       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)
-      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}"
+      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)
-      if Mocha::Configuration.prevent?(:stubbing_method_unnecessarily)
-        raise StubbingError.new("stubbing method unnecessarily: #{expectation.method_signature}", expectation.backtrace)
-      end
-      return unless Mocha::Configuration.warn_when?(:stubbing_method_unnecessarily)
-      logger.warn "stubbing method unnecessarily: #{expectation.method_signature}"
+      check(:stubbing_method_unnecessarily, 'method unnecessarily', expectation.method_signature, expectation.backtrace)
     end
 
     attr_writer :logger
@@ -194,6 +150,14 @@ module Mocha
 
     private
 
+    def check(action, description, method_signature, backtrace = caller)
+      treatment = Mocha.configuration.send(action)
+      return if (treatment == :allow) || (block_given? && !yield)
+      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