mocha 0.10.5 → 1.13.0

data/lib/mocha/expectation_error.rb

@@ -1,15 +1,8 @@
-require 'mocha/backtrace_filter'
-
 module Mocha
-
-  class ExpectationError < Exception
-    
-    def initialize(message = nil, backtrace = [])
-      super(message)
-      filter = BacktraceFilter.new
-      set_backtrace(filter.filtered(backtrace))
-    end
-
-  end
-  
+  # 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,35 @@
+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,11 +1,9 @@
-module Mocha # :nodoc:
-
+module Mocha
   class ExpectationList
-
-    def initialize
-      @expectations = []
+    def initialize(expectations = [])
+      @expectations = expectations
     end
-    
+
     def add(expectation)
       @expectations.unshift(expectation)
       expectation
@@ -14,31 +12,31 @@ module Mocha # :nodoc:
     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 match(method_name, *arguments)
-      matching_expectations(method_name, *arguments).first
+
+    def match(invocation)
+      matching_expectations(invocation).first
     end
-    
-    def match_allowing_invocation(method_name, *arguments)
-      matching_expectations(method_name, *arguments).detect { |e| e.invocations_allowed? }
+
+    def match_allowing_invocation(invocation)
+      matching_expectations(invocation).detect(&:invocations_allowed?)
     end
-    
+
     def verified?(assertion_counter = nil)
       @expectations.all? { |expectation| expectation.verified?(assertion_counter) }
     end
-    
+
     def to_a
       @expectations
     end
-    
+
     def to_set
       @expectations.to_set
     end
-    
+
     def length
       @expectations.length
     end
@@ -47,12 +45,14 @@ module Mocha # :nodoc:
       @expectations.any?
     end
 
+    def +(other)
+      self.class.new(to_a + other.to_a)
+    end
+
     private
-    
-    def matching_expectations(method_name, *arguments)
-      @expectations.select { |e| e.match?(method_name, *arguments) }
+
+    def matching_expectations(invocation)
+      @expectations.select { |e| e.match?(invocation) }
     end
-    
   end
-
 end

data/lib/mocha/hooks.rb

@@ -0,0 +1,42 @@
+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
+    # 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
+      Mockery.setup
+    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(assertion_counter = nil)
+      Mockery.verify(assertion_counter)
+    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
+      Mockery.teardown
+    end
+  end
+end

data/lib/mocha/in_state_ordering_constraint.rb

@@ -1,19 +1,15 @@
 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
+end

data/lib/mocha/inspect.rb

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

data/lib/mocha/instance_method.rb

@@ -1,32 +1,23 @@
-require 'mocha/class_method'
+require 'mocha/stubbed_method'
 
 module Mocha
+  class InstanceMethod < StubbedMethod
+    private
 
-  class InstanceMethod < ClassMethod
-
-    def hide_original_method
-      super if singleton_method?(method)
+    def mock_owner
+      stubbee
     end
 
-    def restore_original_method
-      super if singleton_method?(hidden_method)
+    def method_body(method)
+      PRE_RUBY_V19 ? proc { |*args, &block| method.call(*args, &block) } : method
     end
 
-    def method_exists?(method)
-      return true if stubbee.public_methods(false).include?(method)
-      return true if stubbee.protected_methods(false).include?(method)
-      return true if stubbee.private_methods(false).include?(method)
-      return false
+    def stubbee_method(method_name)
+      stubbee._method(method_name)
     end
 
-    def singleton_method?(method)
-      __metaclass__ = stubbee.__metaclass__
-      return true if __metaclass__.public_instance_methods(false).include?(method)
-      return true if __metaclass__.protected_instance_methods(false).include?(method)
-      return true if __metaclass__.private_instance_methods(false).include?(method)
-      return false
+    def original_method_owner
+      stubbee.singleton_class
     end
-
   end
-
-end
+end

data/lib/mocha/integration/assertion_counter.rb

@@ -0,0 +1,13 @@
+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/mini_test/adapter.rb

@@ -0,0 +1,52 @@
+require 'mocha/api'
+require 'mocha/integration/assertion_counter'
+require 'mocha/expectation_error_factory'
+
+module Mocha
+  module Integration
+    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?(mini_test_version)
+          Gem::Requirement.new('>= 3.3.0').satisfied_by?(mini_test_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
+          mocha_setup
+          super
+        end
+
+        # @private
+        def before_teardown
+          return unless passed?
+          assertion_counter = Integration::AssertionCounter.new(self)
+          mocha_verify(assertion_counter)
+        ensure
+          super
+        end
+
+        # @private
+        def after_teardown
+          super
+          mocha_teardown
+        end
+      end
+    end
+  end
+end

data/lib/mocha/integration/mini_test/exception_translation.rb

@@ -1,20 +1,14 @@
 require 'mocha/expectation_error'
 
 module Mocha
-  
   module Integration
-    
     module MiniTest
-      
       def self.translate(exception)
-        return exception unless exception.kind_of?(::Mocha::ExpectationError)
+        return exception unless exception.is_a?(::Mocha::ExpectationError)
         translated_exception = ::MiniTest::Assertion.new(exception.message)
         translated_exception.set_backtrace(exception.backtrace)
         translated_exception
       end
-      
     end
-    
   end
-  
 end

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

@@ -0,0 +1,19 @@
+module Mocha
+  module Integration
+    module MiniTest
+      module Nothing
+        def self.applicable_to?(_test_unit_version, _ruby_version = nil)
+          true
+        end
+
+        def self.description
+          'nothing (no MiniTest integration available)'
+        end
+
+        def self.included(_mod)
+          raise 'No MiniTest integration available'
+        end
+      end
+    end
+  end
+end

data/lib/mocha/integration/mini_test/version_13.rb

@@ -1,44 +1,54 @@
-require 'mocha/integration/mini_test/assertion_counter'
+require 'mocha/integration/assertion_counter'
+require 'mocha/integration/monkey_patcher'
+require 'mocha/integration/mini_test/exception_translation'
 
 module Mocha
-  
   module Integration
-    
     module MiniTest
-      
       module Version13
+        def self.applicable_to?(mini_test_version)
+          Gem::Requirement.new('>= 1.3.0', '<= 1.3.1').satisfied_by?(mini_test_version)
+        end
+
+        def self.description
+          'monkey patch for MiniTest gem v1.3'
+        end
+
         def self.included(mod)
-          $stderr.puts "Monkey patching MiniTest v1.3" if $mocha_options['debug']
+          MonkeyPatcher.apply(mod, RunMethodPatch)
         end
-        def run runner
-          assertion_counter = AssertionCounter.new(self)
-          result = '.'
-          begin
+
+        module RunMethodPatch
+          # rubocop:disable all
+          def run runner
+            assertion_counter = AssertionCounter.new(self)
+            result = '.'
             begin
-              @passed = nil
-              self.setup
-              self.__send__ self.name
-              mocha_verify(assertion_counter)
-              @passed = true
-            rescue Exception => e
-              @passed = false
-              result = runner.puke(self.class, self.name, Mocha::Integration::MiniTest.translate(e))
-            ensure
               begin
-                self.teardown
+                @passed = nil
+                mocha_setup
+                self.setup
+                self.__send__ self.name
+                mocha_verify(assertion_counter)
+                @passed = true
               rescue Exception => e
+                @passed = false
                 result = runner.puke(self.class, self.name, Mocha::Integration::MiniTest.translate(e))
+              ensure
+                begin
+                  self.teardown
+                rescue Exception => e
+                  result = runner.puke(self.class, self.name, Mocha::Integration::MiniTest.translate(e))
+                end
               end
+            ensure
+              mocha_teardown
             end
-          ensure
-            mocha_teardown
+            result
           end
-          result
+          # rubocop:enable all
         end
       end
-      
     end
-    
   end
-  
 end

data/lib/mocha/integration/mini_test/version_140.rb

@@ -1,45 +1,54 @@
-require 'mocha/integration/mini_test/assertion_counter'
-require 'mocha/expectation_error'
+require 'mocha/integration/assertion_counter'
+require 'mocha/integration/monkey_patcher'
+require 'mocha/integration/mini_test/exception_translation'
 
 module Mocha
-  
   module Integration
-    
     module MiniTest
-      
       module Version140
+        def self.applicable_to?(mini_test_version)
+          Gem::Requirement.new('1.4.0').satisfied_by?(mini_test_version)
+        end
+
+        def self.description
+          'monkey patch for MiniTest gem v1.4.0'
+        end
+
         def self.included(mod)
-          $stderr.puts "Monkey patching MiniTest v1.4.0" if $mocha_options['debug']
+          MonkeyPatcher.apply(mod, RunMethodPatch)
         end
-        def run runner
-          assertion_counter = AssertionCounter.new(self)
-          result = '.'
-          begin
+
+        module RunMethodPatch
+          # rubocop:disable all
+          def run runner
+            assertion_counter = AssertionCounter.new(self)
+            result = '.'
             begin
-              @passed = nil
-              self.setup
-              self.__send__ self.__name__
-              mocha_verify(assertion_counter)
-              @passed = true
-            rescue Exception => e
-              @passed = false
-              result = runner.puke(self.class, self.__name__, Mocha::Integration::MiniTest.translate(e))
-            ensure
               begin
-                self.teardown
+                @passed = nil
+                mocha_setup
+                self.setup
+                self.__send__ self.__name__
+                mocha_verify(assertion_counter)
+                @passed = true
               rescue Exception => e
+                @passed = false
                 result = runner.puke(self.class, self.__name__, Mocha::Integration::MiniTest.translate(e))
+              ensure
+                begin
+                  self.teardown
+                rescue Exception => e
+                  result = runner.puke(self.class, self.__name__, Mocha::Integration::MiniTest.translate(e))
+                end
               end
+            ensure
+              mocha_teardown
             end
-          ensure
-            mocha_teardown
+            result
           end
-          result
+          # rubocop:enable all
         end
       end
-      
     end
-    
   end
-  
 end