mocha 0.5.6 → 3.0.2

data/lib/mocha/expectation_error.rb

@@ -1,15 +1,10 @@
-module Mocha
-
-  class ExpectationError < StandardError
-    
-    LIB_DIRECTORY = File.expand_path(File.join(File.dirname(__FILE__), "..")) + File::SEPARATOR
-    
-    def initialize(message = nil, backtrace = [], lib_directory = LIB_DIRECTORY)
-      super(message)
-      filtered_backtrace = backtrace.reject { |location| Regexp.new(lib_directory).match(File.expand_path(location)) }
-      set_backtrace(filtered_backtrace)
-    end
+# frozen_string_literal: true
 
-  end
-  
-end
+module Mocha
+  # Default exception class raised when an unexpected invocation or an unsatisfied expectation occurs.
+  #
+  # Authors of test libraries may use +Mocha::ExpectationErrorFactory+ to have Mocha raise a different exception.
+  #
+  # @see Mocha::ExpectationErrorFactory
+  class ExpectationError < Exception; end # rubocop:disable Lint/InheritException
+end

data/lib/mocha/expectation_error_factory.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'mocha/backtrace_filter'
+require 'mocha/expectation_error'
+
+module Mocha
+  # This factory determines what class of exception should be raised when Mocha detects a test failure.
+  #
+  # This class should only be used by authors of test libraries and not by typical "users" of Mocha.
+  #
+  # For example, it is used by +Mocha::Integration::Minitest::Adapter+ in order to have Mocha raise a +Minitest::Assertion+ which can then be sensibly handled by +Minitest::Unit::TestCase+.
+  #
+  # @see Mocha::Integration::Minitest::Adapter
+  class ExpectationErrorFactory
+    class << self
+      # @!attribute exception_class
+      #   Determines what class of exception should be raised when Mocha detects a test failure.
+      #
+      #   This attribute may be set by authors of test libraries in order to have Mocha raise exceptions of a specific class when there is an unexpected invocation or an unsatisfied expectation.
+      #
+      #   By default a +Mocha::ExpectationError+ will be raised.
+      #
+      #   @return [Exception] class of exception to be raised when an expectation error occurs
+      #   @see Mocha::ExpectationError
+      attr_accessor :exception_class
+
+      # @private
+      def build(message = nil, backtrace = [])
+        exception = exception_class.new(message)
+        filter = BacktraceFilter.new
+        exception.set_backtrace(filter.filtered(backtrace))
+        exception
+      end
+    end
+    self.exception_class = ExpectationError
+  end
+end

data/lib/mocha/expectation_list.rb

@@ -1,32 +1,38 @@
-module Mocha # :nodoc:
+# frozen_string_literal: true
 
+module Mocha
   class ExpectationList
-
-    def initialize
-      @expectations = []
+    def initialize(expectations = [])
+      @expectations = expectations
     end
 
     def add(expectation)
-      @expectations << expectation
+      @expectations.unshift(expectation)
       expectation
     end
 
+    def remove_all_matching_method(method_name)
+      @expectations.reject! { |expectation| expectation.matches_method?(method_name) }
+    end
+
     def matches_method?(method_name)
       @expectations.any? { |expectation| expectation.matches_method?(method_name) }
     end
 
-    def similar(method_name)
-      @expectations.select { |expectation| expectation.matches_method?(method_name) }
+    def match(invocation, ignoring_order: false)
+      matching_expectations(invocation, ignoring_order: ignoring_order).first
     end
 
-    def detect(method_name, *arguments)
-      expectations = @expectations.reverse.select { |e| e.match?(method_name, *arguments) }
-      expectation = expectations.detect { |e| e.invocations_allowed? }
-      expectation || expectations.first
+    def match_allowing_invocation(invocation)
+      matching_expectations(invocation).detect(&:invocations_allowed?)
     end
 
-    def verify(&block)
-      @expectations.each { |expectation| expectation.verify(&block) }
+    def match_never_allowing_invocation(invocation)
+      matching_expectations(invocation).detect(&:invocations_never_allowed?)
+    end
+
+    def verified?(assertion_counter)
+      @expectations.all? { |expectation| expectation.verified?(assertion_counter) }
     end
 
     def to_a
@@ -41,6 +47,16 @@ module Mocha # :nodoc:
       @expectations.length
     end
 
-  end
+    def any?
+      @expectations.any?
+    end
+
+    def +(other)
+      self.class.new(to_a + other.to_a)
+    end
 
+    def matching_expectations(invocation, ignoring_order: false)
+      @expectations.select { |e| e.match?(invocation, ignoring_order: ignoring_order) }
+    end
+  end
 end

data/lib/mocha/hooks.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require 'mocha/mockery'
+
+module Mocha
+  # Integration hooks for test library authors.
+  #
+  # The methods in this module should be called from test libraries wishing to integrate with Mocha.
+  #
+  # This module is provided as part of the +Mocha::API+ module and is therefore part of the public API, but should only be used by authors of test libraries and not by typical "users" of Mocha.
+  #
+  # Integration with Test::Unit and Minitest are provided as part of Mocha, because they are (or were once) part of the Ruby standard library. Integration with other test libraries is not provided as *part* of Mocha, but is supported by means of the methods in this module.
+  #
+  # See the code in the +Adapter+ modules for examples of how to use the methods in this module. +Mocha::ExpectationErrorFactory+ may be used if you want +Mocha+ to raise a different type of exception.
+  #
+  # @see Mocha::Integration::TestUnit::Adapter
+  # @see Mocha::Integration::Minitest::Adapter
+  # @see Mocha::ExpectationErrorFactory
+  # @see Mocha::API
+  module Hooks
+    # @private
+    class NullAssertionCounter
+      def increment; end
+    end
+
+    # Prepares Mocha before a test (only for use by authors of test libraries).
+    #
+    # This method should be called before each individual test starts (including before any "setup" code).
+    def mocha_setup(assertion_counter = NullAssertionCounter.new)
+      Mockery.setup(assertion_counter)
+    end
+
+    # Verifies that all mock expectations have been met (only for use by authors of test libraries).
+    #
+    # This is equivalent to a series of "assertions".
+    #
+    # This method should be called at the end of each individual test, before it has been determined whether or not the test has passed.
+    def mocha_verify
+      Mockery.verify
+    end
+
+    # Resets Mocha after a test (only for use by authors of test libraries).
+    #
+    # This method should be called after each individual test has finished (including after any "teardown" code).
+    def mocha_teardown(origin = mocha_test_name)
+      Mockery.teardown(origin)
+    end
+
+    # Returns a string representing the unit test name, to be included in some Mocha
+    # to help track down potential bugs.
+    def mocha_test_name
+      nil
+    end
+  end
+end

data/lib/mocha/ignoring_warning.rb

@@ -0,0 +1,20 @@
+module Mocha
+  # @private
+  module IgnoringWarning
+    def ignoring_warning(pattern, if_: true)
+      return yield unless if_
+
+      begin
+        original_warn = Warning.method(:warn)
+        Warning.singleton_class.define_method(:warn) do |message|
+          original_warn.call(message) unless message =~ pattern
+        end
+
+        yield
+      ensure
+        Warning.singleton_class.undef_method(:warn)
+        Warning.singleton_class.define_method(:warn, original_warn)
+      end
+    end
+  end
+end

data/lib/mocha/impersonating_any_instance_name.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Mocha
+  class ImpersonatingAnyInstanceName
+    def initialize(klass)
+      @klass = klass
+    end
+
+    def mocha_inspect
+      "#<AnyInstance:#{@klass.mocha_inspect}>"
+    end
+  end
+end

data/lib/mocha/impersonating_name.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Mocha
+  class ImpersonatingName
+    def initialize(object)
+      @object = object
+    end
+
+    def mocha_inspect
+      @object.mocha_inspect
+    end
+  end
+end

data/lib/mocha/in_state_ordering_constraint.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Mocha
+  class InStateOrderingConstraint
+    def initialize(state_predicate)
+      @state_predicate = state_predicate
+    end
+
+    def allows_invocation_now?
+      @state_predicate.active?
+    end
+
+    def mocha_inspect
+      "when #{@state_predicate.mocha_inspect}"
+    end
+  end
+end

data/lib/mocha/inspect.rb

@@ -1,39 +1,73 @@
+# frozen_string_literal: true
+
 require 'date'
 
-class Object
-  def mocha_inspect
-    address = self.__id__ * 2
-    address += 0x100000000 if address < 0
-    inspect =~ /#</ ? "#<#{self.class}:0x#{'%x' % address}>" : inspect
+module Mocha
+  module Inspect
+    module ObjectMethods
+      def mocha_inspect
+        address = __id__ * 2
+        address += 0x100000000 if address < 0
+        inspect =~ /#</ ? "#<#{self.class}:0x#{Kernel.format('%<address>x', address: address)}>" : inspect
+      end
+    end
+
+    module ArrayMethods
+      def mocha_inspect(wrapped: true)
+        unwrapped = collect(&:mocha_inspect).join(', ')
+        wrapped ? "[#{unwrapped}]" : unwrapped
+      end
+    end
+
+    module HashMethods
+      def mocha_inspect
+        unwrapped = collect do |key, value|
+          case key
+          when Symbol
+            "#{key}: #{value.mocha_inspect}"
+          else
+            "#{key.mocha_inspect} => #{value.mocha_inspect}"
+          end
+        end.join(', ')
+
+        if Hash.ruby2_keywords_hash?(self)
+          empty? ? '**{}' : unwrapped
+        else
+          "{#{unwrapped}}"
+        end
+      end
+    end
+
+    module TimeMethods
+      def mocha_inspect
+        "#{inspect} (#{to_f} secs)"
+      end
+    end
+
+    module DateMethods
+      def mocha_inspect
+        to_s
+      end
+    end
   end
 end
 
-class String
-  def mocha_inspect
-    inspect.gsub(/\"/, "'")
-  end
+class Object
+  include Mocha::Inspect::ObjectMethods
 end
 
 class Array
-  def mocha_inspect
-    "[#{collect { |member| member.mocha_inspect }.join(', ')}]"
-  end
+  include Mocha::Inspect::ArrayMethods
 end
 
 class Hash
-  def mocha_inspect
-    "{#{collect { |key, value| "#{key.mocha_inspect} => #{value.mocha_inspect}" }.join(', ')}}"
-  end
+  include Mocha::Inspect::HashMethods
 end
 
 class Time
-  def mocha_inspect
-    "#{inspect} (#{to_f} secs)"
-  end
+  include Mocha::Inspect::TimeMethods
 end
 
 class Date
-  def mocha_inspect
-    to_s
-  end
-end
+  include Mocha::Inspect::DateMethods
+end

data/lib/mocha/instance_method.rb

@@ -1,8 +1,21 @@
-require 'mocha/class_method'
+# frozen_string_literal: true
+
+require 'mocha/stubbed_method'
 
 module Mocha
+  class InstanceMethod < StubbedMethod
+    private
+
+    def stubbee
+      stubba_object
+    end
+
+    def stubbee_method(method_name)
+      stubba_object._method(method_name)
+    end
 
-  class InstanceMethod < ClassMethod
+    def original_method_owner
+      stubba_object.singleton_class
+    end
   end
-  
-end
+end

data/lib/mocha/integration/assertion_counter.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Mocha
+  module Integration
+    class AssertionCounter
+      def initialize(test_case)
+        @test_case = test_case
+      end
+
+      def increment
+        @test_case.assert(true)
+      end
+    end
+  end
+end

data/lib/mocha/integration/minitest/adapter.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'mocha/api'
+require 'mocha/integration/assertion_counter'
+require 'mocha/expectation_error_factory'
+
+module Mocha
+  module Integration
+    # Contains {Adapter} that integrates Mocha into recent versions of Minitest.
+    module Minitest
+      # Integrates Mocha into recent versions of Minitest.
+      #
+      # See the source code for an example of how to integrate Mocha into a test library.
+      module Adapter
+        include Mocha::API
+
+        # @private
+        def self.applicable_to?(minitest_version)
+          Gem::Requirement.new('>= 3.3.0').satisfied_by?(minitest_version)
+        end
+
+        # @private
+        def self.description
+          'adapter for Minitest gem >= v3.3.0'
+        end
+
+        # @private
+        def self.included(_mod)
+          Mocha::ExpectationErrorFactory.exception_class = ::Minitest::Assertion
+        end
+
+        # @private
+        def before_setup
+          assertion_counter = Integration::AssertionCounter.new(self)
+          mocha_setup(assertion_counter)
+          super
+        end
+
+        # @private
+        def before_teardown
+          return unless passed?
+
+          mocha_verify
+        ensure
+          super
+        end
+
+        # @private
+        def after_teardown
+          super
+          mocha_teardown
+        end
+
+        # @private
+        def mocha_test_name
+          if respond_to?(:name)
+            test_name = name
+          elsif respond_to?(:__name__) # Older minitest
+            test_name = __name__
+          end
+
+          if test_name
+            "#{self.class.name}##{test_name}"
+          else
+            self.class.name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mocha/integration/minitest.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'mocha/detection/minitest'
+require 'mocha/integration/minitest/adapter'
+
+module Mocha
+  module Integration
+    module Minitest
+      def self.activate # rubocop:disable Naming/PredicateMethod
+        target = Detection::Minitest.testcase
+        return false unless target
+
+        minitest_version = Gem::Version.new(Detection::Minitest.version)
+        warn "Detected Minitest version: #{minitest_version}" if $DEBUG
+
+        unless Minitest::Adapter.applicable_to?(minitest_version)
+          raise 'Versions of minitest earlier than v3.3.0 are not supported.'
+        end
+
+        unless target < Minitest::Adapter
+          warn "Applying #{Minitest::Adapter.description}" if $DEBUG
+          target.send(:include, Minitest::Adapter)
+        end
+
+        true
+      end
+    end
+  end
+end

data/lib/mocha/integration/monkey_patcher.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require 'mocha/api'
+
+module Mocha
+  module Integration
+    module MonkeyPatcher
+      def self.apply(mod, run_method_patch)
+        if mod < Mocha::API
+          warn "Mocha::API already included in #{mod}" if $DEBUG
+        else
+          mod.send(:include, Mocha::API)
+        end
+        if mod.method_defined?(:run_before_mocha)
+          warn "#{mod}#run_before_mocha method already defined" if $DEBUG
+        elsif mod.method_defined?(:run)
+          mod.send(:alias_method, :run_before_mocha, :run)
+          mod.send(:remove_method, :run)
+          mod.send(:include, run_method_patch)
+        else
+          raise "Unable to monkey-patch #{mod}, because it does not define a `#run` method"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'mocha/api'
+require 'mocha/integration/assertion_counter'
+require 'mocha/expectation_error'
+
+module Mocha
+  module Integration
+    # Contains {Adapter} that integrates Mocha into recent versions of Test::Unit.
+    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.
+      module Adapter
+        include Mocha::API
+
+        # @private
+        def self.applicable_to?(test_unit_version)
+          Gem::Requirement.new('>= 2.5.1').satisfied_by?(test_unit_version)
+        end
+
+        # @private
+        def self.description
+          'adapter for Test::Unit gem >= v2.5.1'
+        end
+
+        # @private
+        def self.included(mod)
+          mod.setup before: :prepend do
+            assertion_counter = Integration::AssertionCounter.new(self)
+            mocha_setup(assertion_counter)
+          end
+
+          mod.exception_handler(:handle_mocha_expectation_error)
+
+          mod.cleanup after: :append do
+            mocha_verify
+          end
+
+          mod.teardown :mocha_teardown, after: :append
+        end
+
+        private
+
+        # @private
+        def mocha_test_name
+          name
+        end
+
+        # @private
+        def handle_mocha_expectation_error(exception) # rubocop:disable Naming/PredicateMethod
+          return false unless exception.is_a?(Mocha::ExpectationError)
+
+          problem_occurred
+          add_failure(exception.message, exception.backtrace)
+          true
+        end
+      end
+    end
+  end
+end

data/lib/mocha/integration/test_unit.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'mocha/detection/test_unit'
+require 'mocha/integration/test_unit/adapter'
+
+module Mocha
+  module Integration
+    module TestUnit
+      def self.activate # rubocop:disable Naming/PredicateMethod
+        target = Detection::TestUnit.testcase
+        return false unless target
+
+        test_unit_version = Gem::Version.new(Detection::TestUnit.version)
+        warn "Detected Test::Unit version: #{test_unit_version}" if $DEBUG
+
+        unless TestUnit::Adapter.applicable_to?(test_unit_version)
+          raise 'Versions of test-unit earlier than v2.5.1 are not supported.'
+        end
+
+        unless target < TestUnit::Adapter
+          warn "Applying #{TestUnit::Adapter.description}" if $DEBUG
+          target.send(:include, TestUnit::Adapter)
+        end
+
+        true
+      end
+    end
+  end
+end

data/lib/mocha/integration.rb

@@ -0,0 +1,5 @@
+module Mocha
+  # Contains adapters that provide built-in support for +Minitest+ and +Test::Unit+.
+  module Integration
+  end
+end