mocha-macruby 0.9.8.20100129120100 → 0.9.9.20101102121900

data/lib/mocha/integration/mini_test.rb

@@ -2,7 +2,11 @@ require 'mocha/api'
 
 if !MiniTest::Unit::TestCase.ancestors.include?(Mocha::API)
   
-  require 'mocha/integration/mini_test/version_131_and_above'
+  require 'mocha/integration/mini_test/exception_translation'
+  require 'mocha/integration/mini_test/version_13'
+  require 'mocha/integration/mini_test/version_140'
+  require 'mocha/integration/mini_test/version_141'
+  require 'mocha/integration/mini_test/version_142_and_above'
   
   module MiniTest
     class Unit
@@ -10,10 +14,34 @@ if !MiniTest::Unit::TestCase.ancestors.include?(Mocha::API)
         
         include Mocha::API
         
-        alias_method :run_before_mocha, :run
-        remove_method :run
+        # For now workaround a MacRuby bug which makes it impossible to
+        # actually remove a method and include a module which defines it again.
+        #
+        #alias_method :run_before_mocha, :run
+        #remove_method :run
         
-        include Mocha::Integration::MiniTest::Version131AndAbove
+        #mini_test_version = begin
+          #MiniTest::Unit::VERSION
+        #rescue LoadError
+          #'unknown'
+        #end
+        
+        #$stderr.puts "Detected MiniTest version: #{mini_test_version}" if $options['debug']
+        
+        #if (mini_test_version >= '1.3.0') && (mini_test_version <= '1.3.1')
+          #include Mocha::Integration::MiniTest::Version13
+        #elsif (mini_test_version == '1.4.0')
+          #include Mocha::Integration::MiniTest::Version140
+        #elsif (mini_test_version == '1.4.1')
+          #include Mocha::Integration::MiniTest::Version141
+        #elsif (mini_test_version >= '1.4.2') && (mini_test_version <= '1.6.0')
+          #include Mocha::Integration::MiniTest::Version142AndAbove
+        #elsif (mini_test_version > '1.6.0')
+          #$stderr.puts "*** MiniTest integration has not been verified but patching anyway ***" if $options['debug']
+          #include Mocha::Integration::MiniTest::Version142AndAbove
+        #else
+          #$stderr.puts "*** No Mocha integration for MiniTest version ***" if $options['debug']
+        #end
         
       end
     end

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

@@ -0,0 +1,20 @@
+require 'mocha/expectation_error'
+
+module Mocha
+  
+  module Integration
+    
+    module MiniTest
+      
+      def self.translate(exception)
+        return exception unless exception.kind_of?(::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/{version_131_and_above.rb → version_13.rb}

@@ -1,5 +1,4 @@
 require 'mocha/integration/mini_test/assertion_counter'
-require 'mocha/expectation_error'
 
 module Mocha
   
@@ -7,33 +6,28 @@ module Mocha
     
     module MiniTest
       
-      def self.translate(exception)
-        return exception unless exception.kind_of?(::Mocha::ExpectationError)
-        translated_exception = ::MiniTest::Assertion.new(exception.message)
-        translated_exception.set_backtrace(exception.backtrace)
-        translated_exception
-      end
-      
-      module Version131AndAbove
+      module Version13
+        def self.included(mod)
+          $stderr.puts "Monkey patching MiniTest v1.3" if $options['debug']
+        end
         def run runner
           assertion_counter = AssertionCounter.new(self)
           result = '.'
-          name = (self.respond_to?(:name) ? self.name : self.__name__)
           begin
             begin
               @passed = nil
               self.setup
-              self.__send__ name
+              self.__send__ self.name
               mocha_verify(assertion_counter)
               @passed = true
             rescue Exception => e
               @passed = false
-              result = runner.puke(self.class, name, Mocha::Integration::MiniTest.translate(e))
+              result = runner.puke(self.class, self.name, Mocha::Integration::MiniTest.translate(e))
             ensure
               begin
                 self.teardown
               rescue Exception => e
-                result = runner.puke(self.class, name, Mocha::Integration::MiniTest.translate(e))
+                result = runner.puke(self.class, self.name, Mocha::Integration::MiniTest.translate(e))
               end
             end
           ensure

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

@@ -0,0 +1,52 @@
+require 'mocha/integration/mini_test/assertion_counter'
+require 'mocha/expectation_error'
+
+module Mocha
+  
+  module Integration
+    
+    module MiniTest
+      
+      module Version140
+        def self.included(mod)
+          $stderr.puts "Monkey patching MiniTest v1.4.0" if $options['debug']
+        end
+        def run runner
+          assertion_counter = AssertionCounter.new(self)
+          result = '.'
+          begin
+            @passed = nil
+            self.setup
+            self.__send__ name
+            mocha_verify(assertion_counter)
+            @passed = true
+          rescue Exception => e
+            @passed = false
+            result = runner.puke(self.class, name, self.class.translate_exception(e))
+          ensure
+            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
+              rescue Exception => e
+                result = runner.puke(self.class, self.__name__, Mocha::Integration::MiniTest.translate(e))
+              end
+            end
+          end
+        ensure
+          mocha_teardown
+        end
+        result
+      end
+      
+    end
+  end
+end

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

@@ -0,0 +1,56 @@
+require 'mocha/integration/mini_test/assertion_counter'
+require 'mocha/expectation_error'
+
+module Mocha
+  
+  module Integration
+    
+    module MiniTest
+            
+      module Version141
+        def self.included(mod)
+          $stderr.puts "Monkey patching MiniTest v1.4.1"
+        end
+        def run runner
+          trap 'INFO' do
+            warn '%s#%s %.2fs' % [self.class, self.__name__,
+              (Time.now - runner.start_time)]
+            runner.status $stderr
+          end
+
+          assertion_counter = AssertionCounter.new(self)
+          result = '.'
+          begin
+            begin
+              @passed = nil
+              self.setup
+              self.__send__ self.__name__
+              mocha_verify(assertion_counter)
+              @passed = true
+            rescue *::MiniTest::Unit::TestCase::PASSTHROUGH_EXCEPTIONS
+              raise
+            rescue Exception => e
+              @passed = false
+              result = runner.puke(self.class, self.__name__, Mocha::Integration::MiniTest.translate(e))
+            ensure
+              begin
+                self.teardown
+              rescue *::MiniTest::Unit::TestCase::PASSTHROUGH_EXCEPTIONS
+                raise
+              rescue Exception => e
+                result = runner.puke(self.class, self.__name__, Mocha::Integration::MiniTest.translate(e))
+              end
+              trap 'INFO', 'DEFAULT'
+            end
+          ensure
+            mocha_teardown
+          end
+          result
+        end
+      end
+      
+    end
+    
+  end
+  
+end

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

@@ -0,0 +1,47 @@
+require 'mocha/integration/mini_test/assertion_counter'
+require 'mocha/expectation_error'
+
+module MiniTest
+  class Unit
+    class TestCase
+      $stderr.puts "Monkey patching MiniTest >= v1.4.2" if $options['debug']
+      
+      def run runner
+        trap 'INFO' do
+          warn '%s#%s %.2fs' % [self.class, self.__name__,
+            (Time.now - runner.start_time)]
+          runner.status $stderr
+        end if ::MiniTest::Unit::TestCase::SUPPORTS_INFO_SIGNAL
+        
+        assertion_counter = AssertionCounter.new(self)
+        result = '.'
+        begin
+          @passed = nil
+          self.setup
+          self.__send__ self.__name__
+          mocha_verify(assertion_counter)
+          @passed = true
+        rescue *::MiniTest::Unit::TestCase::PASSTHROUGH_EXCEPTIONS
+          raise
+        rescue Exception => e
+          @passed = false
+          result = runner.puke(self.class, self.__name__, Mocha::Integration::MiniTest.translate(e))
+        ensure
+          begin
+            self.teardown
+          rescue *PASSTHROUGH_EXCEPTIONS
+            raise
+          rescue Exception => e
+            result = runner.puke(self.class, self.__name__, Mocha::Integration::MiniTest.translate(e))
+          end
+          trap 'INFO', 'DEFAULT' if ::MiniTest::Unit::TestCase::SUPPORTS_INFO_SIGNAL
+        end
+      ensure
+        mocha_teardown
+      end
+      result
+    end
+    
+  end
+  
+end

data/lib/mocha/integration/test_unit.rb

@@ -3,7 +3,8 @@ require 'mocha/api'
 if !Test::Unit::TestCase.ancestors.include?(Mocha::API)
  
   require 'mocha/integration/test_unit/gem_version_200'
-  require 'mocha/integration/test_unit/gem_version_201_and_above'
+  require 'mocha/integration/test_unit/gem_version_201_to_202'
+  require 'mocha/integration/test_unit/gem_version_203_to_209'
   require 'mocha/integration/test_unit/ruby_version_185_and_below'
   require 'mocha/integration/test_unit/ruby_version_186_and_above'
   
@@ -17,20 +18,34 @@ if !Test::Unit::TestCase.ancestors.include?(Mocha::API)
         remove_method :run
         
         test_unit_version = begin
-          require 'test/unit/version'
+          load 'test/unit/version.rb'
           Test::Unit::VERSION
         rescue LoadError
           '1.x'
         end
 
-        if test_unit_version == '2.0.0'
+        if $options['debug']
+          $stderr.puts "Detected Ruby version: #{RUBY_VERSION}"
+          $stderr.puts "Detected Test::Unit version: #{test_unit_version}"
+        end
+
+        if (test_unit_version == '1.x') || (test_unit_version == '1.2.3')
+          if RUBY_VERSION < '1.8.6'
+            include Mocha::Integration::TestUnit::RubyVersion185AndBelow
+          else
+            include Mocha::Integration::TestUnit::RubyVersion186AndAbove
+          end
+        elsif (test_unit_version == '2.0.0')
           include Mocha::Integration::TestUnit::GemVersion200
-        elsif test_unit_version >= '2.0.1'
-          include Mocha::Integration::TestUnit::GemVersion201AndAbove
-        elsif RUBY_VERSION < '1.8.6'
-          include Mocha::Integration::TestUnit::RubyVersion185AndBelow
+        elsif (test_unit_version >= '2.0.1') && (test_unit_version <= '2.0.2')
+          include Mocha::Integration::TestUnit::GemVersion201To202
+        elsif (test_unit_version >= '2.0.3') && (test_unit_version <= '2.0.9')
+          include Mocha::Integration::TestUnit::GemVersion203To209
+        elsif (test_unit_version > '2.0.9')
+          $stderr.puts "*** Test::Unit integration has not been verified but patching anyway ***" if $options['debug']
+          include Mocha::Integration::TestUnit::GemVersion203To209
         else
-          include Mocha::Integration::TestUnit::RubyVersion186AndAbove
+          $stderr.puts "*** No Mocha integration for Test::Unit version ***" if $options['debug']
         end
         
       end

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

@@ -9,6 +9,9 @@ module Mocha
     module TestUnit
       
       module GemVersion200
+        def self.included(mod)
+          $stderr.puts "Monkey patching Test::Unit gem v2.0.0" if $options['debug']
+        end
         def run(result)
           assertion_counter = AssertionCounter.new(result)
           begin

data/lib/mocha/integration/test_unit/{gem_version_201_and_above.rb → gem_version_201_to_202.rb}

@@ -8,7 +8,10 @@ module Mocha
     
     module TestUnit
       
-      module GemVersion201AndAbove
+      module GemVersion201To202
+        def self.included(mod)
+          $stderr.puts "Monkey patching Test::Unit gem >= v2.0.1 and <= v2.0.2" if $options['debug']
+        end
         def run(result)
           assertion_counter = AssertionCounter.new(result)
           begin

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

@@ -0,0 +1,52 @@
+require 'test/unit/testcase'
+require 'mocha/integration/test_unit/assertion_counter'
+require 'mocha/expectation_error'
+
+module Mocha
+  
+  module Integration
+    
+    module TestUnit
+      
+      module GemVersion203To209
+        def self.included(mod)
+          $stderr.puts "Monkey patching Test::Unit gem >= v2.0.3 and <= v2.0.9" if $options['debug']
+        end
+        def run(result)
+          assertion_counter = AssertionCounter.new(result)
+          begin
+            @_result = result
+            yield(Test::Unit::TestCase::STARTED, name)
+            begin
+              begin
+                run_setup
+                run_test
+                mocha_verify(assertion_counter)
+              rescue Mocha::ExpectationError => e
+                add_failure(e.message, e.backtrace)
+              rescue Exception
+                @interrupted = true
+                raise unless handle_exception($!)
+              ensure
+                begin
+                  run_teardown
+                rescue Exception
+                  raise unless handle_exception($!)
+                end
+              end
+            ensure
+              mocha_teardown
+            end
+            result.add_run
+            yield(Test::Unit::TestCase::FINISHED, name)
+          ensure
+            # @_result = nil # For test-spec's after_all :<
+          end
+        end
+      end
+      
+    end
+    
+  end
+  
+end

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

@@ -9,6 +9,9 @@ module Mocha
     module TestUnit
       
       module RubyVersion185AndBelow
+        def self.included(mod)
+          $stderr.puts "Monkey patching Test::Unit for Ruby <= v1.8.5" if $options['debug']
+        end
         def run(result)
           assertion_counter = AssertionCounter.new(result)
           yield(Test::Unit::TestCase::STARTED, name)

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

@@ -9,6 +9,9 @@ module Mocha
     module TestUnit
       
       module RubyVersion186AndAbove
+        def self.included(mod)
+          $stderr.puts "Monkey patching Test::Unit for Ruby >= v1.8.6" if $options['debug']
+        end
         def run(result)
           assertion_counter = AssertionCounter.new(result)
           yield(Test::Unit::TestCase::STARTED, name)

data/lib/mocha/mock.rb

@@ -2,7 +2,6 @@ require 'mocha/expectation'
 require 'mocha/expectation_list'
 require 'mocha/metaclass'
 require 'mocha/names'
-require 'mocha/mockery'
 require 'mocha/method_matcher'
 require 'mocha/parameters_matcher'
 require 'mocha/unexpected_invocation'
@@ -43,7 +42,7 @@ module Mocha # :nodoc:
       iterator = ArgumentIterator.new(method_name_or_hash)
       iterator.each { |*args|
         method_name = args.shift
-        ensure_method_not_already_defined(method_name)
+        __define_stub_method__(method_name)
         expectation = Expectation.new(self, method_name, backtrace)
         expectation.returns(args.shift) if args.length > 0
         @expectations.add(expectation)
@@ -75,7 +74,7 @@ module Mocha # :nodoc:
       iterator = ArgumentIterator.new(method_name_or_hash)
       iterator.each { |*args|
         method_name = args.shift
-        ensure_method_not_already_defined(method_name)
+        __define_stub_method__(method_name)
         expectation = Expectation.new(self, method_name, backtrace)
         expectation.at_least(0)
         expectation.returns(args.shift) if args.length > 0
@@ -148,21 +147,11 @@ module Mocha # :nodoc:
 
     def stub_everything
       @everything_stubbed = true
+      ANCESTOR_INSTANCE_METHODS.each { |m| __define_stub_method__(m) }
     end
     
     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 = @expectations.match_allowing_invocation(symbol, *arguments)
-        matching_expectation_allowing_invocation.invoke(&block)
-      else
-        if (matching_expectation = @expectations.match(symbol, *arguments)) || (!matching_expectation && !@everything_stubbed)
-          message = UnexpectedInvocation.new(self, symbol, *arguments).to_s
-          message << Mockery.instance.mocha_inspect
-          raise ExpectationError.new(message, caller)
-        end
-      end
+      __match_invocation__(symbol, arguments, block)
     end
     
     def respond_to?(symbol, include_private = false)
@@ -188,11 +177,37 @@ module Mocha # :nodoc:
     def inspect
       mocha_inspect
     end
-    
-    def ensure_method_not_already_defined(method_name)
-      self.__metaclass__.send(:undef_method, method_name) if self.__metaclass__.method_defined?(method_name)
+
+    def __define_stub_method__(symbol)
+      verbose, $VERBOSE = $VERBOSE, nil
+      __metaclass__.class_eval(%{
+        def #{symbol}(*args, &block)
+          __match_invocation__('#{symbol}'.to_sym, args, block)
+        end
+      })
+    ensure
+      $VERBOSE = verbose
     end
 
+    def __match_invocation__(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 = @expectations.match_allowing_invocation(symbol, *arguments)
+        matching_expectation_allowing_invocation.invoke(&block)
+      else
+        if (matching_expectation = @expectations.match(symbol, *arguments)) || (!matching_expectation && !@everything_stubbed)
+          message = UnexpectedInvocation.new(self, symbol, *arguments).to_s
+          message << Mockery.instance.mocha_inspect
+          raise ExpectationError.new(message, caller)
+        end
+      end
+    end
+
+    methods = instance_methods - instance_methods(false)
+    methods.delete(:object_id) unless RUBY_VERSION < '1.9'
+    ANCESTOR_INSTANCE_METHODS = methods.reject { |m| m =~ /^__.*__$/ }
+
     # :startdoc:
 
   end