mocha 1.4.0 → 2.1.0

data/lib/mocha/mock.rb

@@ -1,22 +1,26 @@
-require 'metaclass'
+require 'ruby2_keywords'
 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 +73,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()
@@ -105,24 +108,26 @@ 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 { |*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
+      expectation
     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()
@@ -141,36 +146,48 @@ 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 { |*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
+      expectation
     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
+    #   object = mock('mock')
     #   object.stubs(:stubbed_method).returns(:result_one)
     #   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.
+    # 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.
     #
@@ -220,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.
     #
@@ -253,7 +270,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 +278,7 @@ 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
+      @expired = false
     end
 
     # @private
@@ -274,6 +288,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,44 +309,31 @@ module Mocha
     end
 
     # @private
+    # rubocop:disable Style/MethodMissingSuper
     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}"
-      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)
-        end
-      end
+      handle_method_call(symbol, arguments, block)
     end
+    ruby2_keywords(:method_missing)
+    # rubocop:enable Style/MethodMissingSuper
 
     # @private
-    def respond_to_missing?(symbol, include_private = false)
-      if @responder then
-        if @responder.method(:respond_to?).arity > 1
-          @responder.respond_to?(symbol, include_private)
-        else
-          @responder.respond_to?(symbol)
-        end
-      else
-        @everything_stubbed || all_expectations.matches_method?(symbol)
+    def handle_method_call(symbol, arguments, block)
+      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
 
     # @private
-    if PRE_RUBY_V19
-      def respond_to?(symbol, include_private = false)
-        respond_to_missing?(symbol, include_private)
+    def respond_to_missing?(symbol, _include_all)
+      if @responder
+        @responder.respond_to?(symbol)
+      else
+        @everything_stubbed || all_expectations.matches_method?(symbol)
       end
     end
 
@@ -339,6 +342,11 @@ module Mocha
       @expectations.verified?(assertion_counter)
     end
 
+    # @private
+    def __expire__
+      @expired = true
+    end
+
     # @private
     def mocha_inspect
       @name.mocha_inspect
@@ -351,7 +359,7 @@ 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
@@ -359,6 +367,34 @@ module Mocha
       @expectations.any?
     end
 
-  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
+      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'
@@ -7,16 +6,42 @@ require 'mocha/state_machine'
 require 'mocha/logger'
 require 'mocha/configuration'
 require 'mocha/stubbing_error'
+require 'mocha/not_initialized_error'
 require 'mocha/expectation_error_factory'
 
 module Mocha
-
   class Mockery
+    class Null < self
+      def add_mock(*)
+        raise_not_initialized_error
+      end
 
-    class << self
+      def add_state_machine(*)
+        raise_not_initialized_error
+      end
+
+      def stubba
+        Central::Null.new(&method(:raise_not_initialized_error))
+      end
 
+      private
+
+      def raise_not_initialized_error
+        message = 'Mocha methods cannot be used outside the context of a test'
+        raise NotInitializedError.new(message, caller)
+      end
+    end
+
+    class << self
       def instance
-        @instance ||= new
+        @instances.last || Null.new
+      end
+
+      def setup
+        @instances ||= []
+        mockery = new
+        mockery.logger = instance.logger unless @instances.empty?
+        @instances.push(mockery)
       end
 
       def verify(*args)
@@ -25,28 +50,25 @@ module Mocha
 
       def teardown
         instance.teardown
+      ensure
+        @instances.pop
       end
-
-      def reset_instance
-        @instance = nil
-      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)
@@ -56,24 +78,22 @@ module Mocha
     def verify(assertion_counter = nil)
       unless mocks.all? { |mock| mock.__verified__?(assertion_counter) }
         message = "not all expectations were satisfied\n#{mocha_inspect}"
-        if unsatisfied_expectations.empty?
-          backtrace = caller
-        else
-          backtrace = unsatisfied_expectations[0].backtrace
-        end
+        backtrace = if unsatisfied_expectations.empty?
+                      caller
+                    else
+                      unsatisfied_expectations[0].backtrace
+                    end
         raise ExpectationErrorFactory.build(message, backtrace)
       end
-      expectations.each do |e|
-        unless Mocha::Configuration.allow?(:stubbing_method_unnecessarily)
-          unless e.used?
-            on_stubbing_method_unnecessarily(e)
-          end
-        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
 
@@ -90,78 +110,23 @@ module Mocha
     end
 
     def mocha_inspect
-      message = ""
-      message << "unsatisfied expectations:\n- #{unsatisfied_expectations.map { |e| e.mocha_inspect }.join("\n- ")}\n" unless unsatisfied_expectations.empty?
-      message << "satisfied expectations:\n- #{satisfied_expectations.map { |e| e.mocha_inspect }.join("\n- ")}\n" unless satisfied_expectations.empty?
-      message << "states:\n- #{state_machines.map { |sm| sm.mocha_inspect }.join("\n- ")}" unless state_machines.empty?
+      message = ''
+      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, include_public_methods = true)
-          on_stubbing_non_existent_method(object, method)
-        end
-      end
-      unless Mocha::Configuration.allow?(:stubbing_non_public_method)
-        if object.method_exists?(method, include_public_methods = 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
-      unless Mocha::Configuration.allow?(:stubbing_method_on_non_mock_object)
-        on_stubbing_method_on_non_mock_object(object, method)
-      end
-    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)
+      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))
       end
-      if Mocha::Configuration.warn_when?(:stubbing_non_existent_method)
-        logger.warn "stubbing non-existent method: #{object.mocha_inspect}.#{method}"
-      end
-    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
-      if Mocha::Configuration.warn_when?(:stubbing_non_public_method)
-        logger.warn "stubbing non-public method: #{object.mocha_inspect}.#{method}"
-      end
-    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
-      if Mocha::Configuration.warn_when?(:stubbing_method_on_nil)
-        logger.warn "stubbing method on nil: #{object.mocha_inspect}.#{method}"
-      end
-    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
-      if Mocha::Configuration.warn_when?(:stubbing_method_on_non_mock_object)
-        logger.warn "stubbing method on non-mock object: #{object.mocha_inspect}.#{method}"
-      end
-    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
-      if Mocha::Configuration.warn_when?(:stubbing_method_unnecessarily)
-        logger.warn "stubbing method unnecessarily: #{expectation.method_signature}"
+      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', signature_proc) { object.nil? }
+      check(:stubbing_method_on_non_mock_object, 'method on non-mock object', signature_proc)
     end
 
     attr_writer :logger
@@ -170,19 +135,27 @@ module Mocha
       @logger ||= Logger.new($stderr)
     end
 
-
     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
 
     def unsatisfied_expectations
-      expectations.reject { |e| e.verified? }
+      expectations.reject(&:verified?)
     end
 
     def satisfied_expectations
-      expectations.select { |e| e.verified? }
+      expectations.select(&:verified?)
     end
 
     def add_mock(mock)
@@ -200,7 +173,5 @@ module Mocha
       @mocks = nil
       @state_machines = nil
     end
-
   end
-
 end

data/lib/mocha/names.rb

@@ -1,7 +1,5 @@
 module Mocha
-
   class ImpersonatingName
-
     def initialize(object)
       @object = object
     end
@@ -9,11 +7,9 @@ module Mocha
     def mocha_inspect
       @object.mocha_inspect
     end
-
   end
 
   class ImpersonatingAnyInstanceName
-
     def initialize(klass)
       @klass = klass
     end
@@ -21,23 +17,19 @@ module Mocha
     def mocha_inspect
       "#<AnyInstance:#{@klass.mocha_inspect}>"
     end
-
   end
 
   class Name
-
     def initialize(name)
-      @name = name
+      @name = name.to_s
     end
 
     def mocha_inspect
       "#<Mock:#{@name}>"
     end
-
   end
 
   class DefaultName
-
     def initialize(mock)
       @mock = mock
     end
@@ -45,9 +37,7 @@ module Mocha
     def mocha_inspect
       address = @mock.__id__ * 2
       address += 0x100000000 if address < 0
-      "#<Mock:0x#{'%x' % address}>"
+      "#<Mock:0x#{format('%<address>x', address: address)}>"
     end
-
   end
-
 end

data/lib/mocha/not_initialized_error.rb

@@ -0,0 +1,7 @@
+require 'mocha/error_with_filtered_backtrace'
+
+module Mocha
+  # Exception raised when Mocha has not been initialized, e.g. outside the
+  # context of a test.
+  class NotInitializedError < ErrorWithFilteredBacktrace; end
+end