mocha 1.6.0 → 1.10.1

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/integration/test_unit/adapter.rb

@@ -5,7 +5,6 @@ require 'mocha/expectation_error'
 module Mocha
   module Integration
     module TestUnit
-
       # Integrates Mocha into recent versions of Test::Unit.
       #
       # See the source code for an example of how to integrate Mocha into a test library.
@@ -13,13 +12,13 @@ module Mocha
         include Mocha::API
 
         # @private
-        def self.applicable_to?(test_unit_version, ruby_version = nil)
+        def self.applicable_to?(test_unit_version, _ruby_version = nil)
           Gem::Requirement.new('>= 2.5.1').satisfied_by?(test_unit_version)
         end
 
         # @private
         def self.description
-          "adapter for Test::Unit gem >= v2.5.1"
+          'adapter for Test::Unit gem >= v2.5.1'
         end
 
         # @private
@@ -39,10 +38,10 @@ module Mocha
         private
 
         # @private
-        def handle_mocha_expectation_error(e)
-          return false unless e.is_a?(Mocha::ExpectationError)
+        def handle_mocha_expectation_error(exception)
+          return false unless exception.is_a?(Mocha::ExpectationError)
           problem_occurred
-          add_failure(e.message, e.backtrace)
+          add_failure(exception.message, exception.backtrace)
           true
         end
       end

data/lib/mocha/integration/test_unit/gem_version_200.rb

@@ -6,12 +6,12 @@ module Mocha
   module Integration
     module TestUnit
       module GemVersion200
-        def self.applicable_to?(test_unit_version, ruby_version = nil)
+        def self.applicable_to?(test_unit_version, _ruby_version = nil)
           Gem::Requirement.new('2.0.0').satisfied_by?(test_unit_version)
         end
 
         def self.description
-          "monkey patch for Test::Unit gem v2.0.0"
+          'monkey patch for Test::Unit gem v2.0.0'
         end
 
         def self.included(mod)
@@ -19,6 +19,7 @@ module Mocha
         end
 
         module RunMethodPatch
+          # rubocop:disable all
           def run(result)
             assertion_counter = AssertionCounter.new(self)
             begin
@@ -53,6 +54,7 @@ module Mocha
               @_result = nil
             end
           end
+          # rubocop:enable all
         end
       end
     end

data/lib/mocha/integration/test_unit/gem_version_201_to_202.rb

@@ -6,12 +6,12 @@ module Mocha
   module Integration
     module TestUnit
       module GemVersion201To202
-        def self.applicable_to?(test_unit_version, ruby_version = nil)
+        def self.applicable_to?(test_unit_version, _ruby_version = nil)
           Gem::Requirement.new('>= 2.0.1', '<= 2.0.2').satisfied_by?(test_unit_version)
         end
 
         def self.description
-          "monkey patch for Test::Unit gem >= v2.0.1 and <= v2.0.2"
+          'monkey patch for Test::Unit gem >= v2.0.1 and <= v2.0.2'
         end
 
         def self.included(mod)
@@ -19,6 +19,7 @@ module Mocha
         end
 
         module RunMethodPatch
+          # rubocop:disable all
           def run(result)
             assertion_counter = AssertionCounter.new(self)
             begin
@@ -53,6 +54,7 @@ module Mocha
               @_result = nil
             end
           end
+          # rubocop:enable all
         end
       end
     end

data/lib/mocha/integration/test_unit/gem_version_203_to_220.rb

@@ -6,12 +6,12 @@ module Mocha
   module Integration
     module TestUnit
       module GemVersion203To220
-        def self.applicable_to?(test_unit_version, ruby_version = nil)
+        def self.applicable_to?(test_unit_version, _ruby_version = nil)
           Gem::Requirement.new('>= 2.0.3', '<= 2.2.0').satisfied_by?(test_unit_version)
         end
 
         def self.description
-          "monkey patch for Test::Unit gem >= v2.0.3 and <= v2.2.0"
+          'monkey patch for Test::Unit gem >= v2.0.3 and <= v2.2.0'
         end
 
         def self.included(mod)
@@ -19,6 +19,7 @@ module Mocha
         end
 
         module RunMethodPatch
+          # rubocop:disable all
           def run(result)
             assertion_counter = AssertionCounter.new(self)
             begin
@@ -53,6 +54,7 @@ module Mocha
               # @_result = nil # For test-spec's after_all :<
             end
           end
+          # rubocop:enable all
         end
       end
     end

data/lib/mocha/integration/test_unit/gem_version_230_to_250.rb

@@ -6,12 +6,12 @@ module Mocha
   module Integration
     module TestUnit
       module GemVersion230To250
-        def self.applicable_to?(test_unit_version, ruby_version = nil)
+        def self.applicable_to?(test_unit_version, _ruby_version = nil)
           Gem::Requirement.new('>= 2.3.0', '<= 2.5.0').satisfied_by?(test_unit_version)
         end
 
         def self.description
-          "monkey patch for Test::Unit gem >= v2.3.0 and <= v2.5.0"
+          'monkey patch for Test::Unit gem >= v2.3.0 and <= v2.5.0'
         end
 
         def self.included(mod)
@@ -19,6 +19,7 @@ module Mocha
         end
 
         module RunMethodPatch
+          # rubocop:disable all
           def run(result)
             assertion_counter = AssertionCounter.new(self)
             begin
@@ -59,6 +60,7 @@ module Mocha
               # @_result = nil # For test-spec's after_all :<
             end
           end
+          # rubocop:enable all
         end
       end
     end

data/lib/mocha/integration/test_unit/nothing.rb

@@ -2,16 +2,16 @@ module Mocha
   module Integration
     module TestUnit
       module Nothing
-        def self.applicable_to?(test_unit_version, ruby_version = nil)
+        def self.applicable_to?(_test_unit_version, _ruby_version = nil)
           true
         end
 
         def self.description
-          "nothing (no Test::Unit integration available)"
+          'nothing (no Test::Unit integration available)'
         end
 
-        def self.included(mod)
-          raise "No Test::Unit integration available"
+        def self.included(_mod)
+          raise 'No Test::Unit integration available'
         end
       end
     end

data/lib/mocha/integration/test_unit/ruby_version_185_and_below.rb

@@ -11,7 +11,7 @@ module Mocha
         end
 
         def self.description
-          "monkey patch for standard library in Ruby <= v1.8.5"
+          'monkey patch for standard library in Ruby <= v1.8.5'
         end
 
         def self.included(mod)
@@ -19,6 +19,7 @@ module Mocha
         end
 
         module RunMethodPatch
+          # rubocop:disable all
           def run(result)
             assertion_counter = AssertionCounter.new(self)
             yield(Test::Unit::TestCase::STARTED, name)
@@ -52,6 +53,7 @@ module Mocha
             result.add_run
             yield(Test::Unit::TestCase::FINISHED, name)
           end
+          # rubocop:enable all
         end
       end
     end

data/lib/mocha/integration/test_unit/ruby_version_186_and_above.rb

@@ -11,7 +11,7 @@ module Mocha
         end
 
         def self.description
-          "monkey patch for standard library Test::Unit in Ruby >= v1.8.6"
+          'monkey patch for standard library Test::Unit in Ruby >= v1.8.6'
         end
 
         def self.included(mod)
@@ -19,6 +19,7 @@ module Mocha
         end
 
         module RunMethodPatch
+          # rubocop:disable all
           def run(result)
             assertion_counter = AssertionCounter.new(self)
             yield(Test::Unit::TestCase::STARTED, name)
@@ -54,6 +55,7 @@ module Mocha
             result.add_run
             yield(Test::Unit::TestCase::FINISHED, name)
           end
+          # rubocop:enable all
         end
       end
     end

data/lib/mocha/invocation.rb

@@ -0,0 +1,61 @@
+require 'mocha/parameters_matcher'
+require 'mocha/raised_exception'
+require 'mocha/return_values'
+require 'mocha/thrown_object'
+require 'mocha/yield_parameters'
+
+module Mocha
+  class Invocation
+    attr_reader :method_name
+
+    def initialize(mock, method_name, *arguments)
+      @mock = mock
+      @method_name = method_name
+      @arguments = arguments
+      @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)
+        yield(*yield_args)
+      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
+      "#{@mock.mocha_inspect}.#{@method_name}#{ParametersMatcher.new(@arguments).mocha_inspect}"
+    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/is_a.rb

@@ -1,9 +1,7 @@
 class Object
-
   # :stopdoc:
 
   alias_method :__is_a__, :is_a?
 
   # :startdoc:
-
 end

data/lib/mocha/logger.rb

@@ -1,7 +1,5 @@
 module Mocha
-
   class Logger
-
     def initialize(io)
       @io = io
     end
@@ -9,7 +7,5 @@ module Mocha
     def warn(message)
       @io.puts "WARNING: #{message}"
     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/method_matcher.rb

@@ -1,7 +1,5 @@
 module Mocha
-
   class MethodMatcher
-
     attr_reader :expected_method_name
 
     def initialize(expected_method_name)
@@ -13,9 +11,7 @@ module Mocha
     end
 
     def mocha_inspect
-      "#{@expected_method_name}"
+      @expected_method_name.to_s
     end
-
   end
-
 end

data/lib/mocha/minitest.rb

@@ -1,3 +1,8 @@
-require "mocha/integration/mini_test"
+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,22 +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
@@ -69,15 +74,14 @@ module Mocha
   # different mock objects, use the {Expectation#in_sequence} method to
   # explicitly define a total or partial ordering of invocations.
   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()
@@ -106,23 +110,23 @@ module Mocha
     #   object.expects(:expected_method_two).returns(:result_two)
     def expects(method_name_or_hash, backtrace = nil)
       iterator = ArgumentIterator.new(method_name_or_hash)
-      iterator.each { |*args|
+      iterator.each do |*args|
         method_name = args.shift
         ensure_method_not_already_defined(method_name)
         expectation = Expectation.new(self, method_name, backtrace)
-        expectation.returns(args.shift) if args.length > 0
+        expectation.returns(args.shift) unless args.empty?
         @expectations.add(expectation)
-      }
+      end
     end
 
     # 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()
@@ -142,19 +146,19 @@ module Mocha
     #   object.stubs(:stubbed_method_two).returns(:result_two)
     def stubs(method_name_or_hash, backtrace = nil)
       iterator = ArgumentIterator.new(method_name_or_hash)
-      iterator.each { |*args|
+      iterator.each do |*args|
         method_name = args.shift
         ensure_method_not_already_defined(method_name)
         expectation = Expectation.new(self, method_name, backtrace)
         expectation.at_least(0)
-        expectation.returns(args.shift) if args.length > 0
+        expectation.returns(args.shift) unless args.empty?
         @expectations.add(expectation)
-      }
+      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
@@ -162,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.
@@ -253,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)
@@ -261,10 +275,6 @@ module Mocha
       @everything_stubbed = false
       @responder = nil
       @unexpected_invocation = nil
-      if block
-        Deprecation.warning('Passing a block is deprecated. Use Object#tap or define stubs/expectations with an explicit receiver instead.')
-        instance_eval(&block)
-      end
     end
 
     # @private
@@ -274,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
 
@@ -293,30 +305,30 @@ module Mocha
     end
 
     # @private
+    # rubocop:disable Style/MethodMissingSuper,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
     def method_missing(symbol, *arguments, &block)
-      if @responder and not @responder.respond_to?(symbol)
-        raise NoMethodError, "undefined method `#{symbol}' for #{self.mocha_inspect} which responds like #{@responder.mocha_inspect}"
+      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)
-      else
-        if (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)
+      invocation = Invocation.new(self, symbol, *arguments)
+      if (matching_expectation_allowing_invocation = all_expectations.match_allowing_invocation(invocation))
+        matching_expectation_allowing_invocation.invoke(invocation, &block)
+      elsif (matching_expectation = all_expectations.match(invocation)) || (!matching_expectation && !@everything_stubbed)
+        if @unexpected_invocation.nil?
+          @unexpected_invocation = invocation
+          matching_expectation.invoke(invocation, &block) 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
     end
+    # rubocop:enable Style/MethodMissingSuper,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
 
     # @private
     def respond_to_missing?(symbol, include_private = false)
-      if @responder then
+      if @responder
         if @responder.method(:respond_to?).arity > 1
           @responder.respond_to?(symbol, include_private)
         else
@@ -351,14 +363,12 @@ module Mocha
 
     # @private
     def ensure_method_not_already_defined(method_name)
-      self.__metaclass__.send(:undef_method, method_name) if self.__metaclass__.method_defined?(method_name) || self.__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
-
   end
-
 end