mocha 0.12.8 → 0.13.0

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

@@ -1,59 +1,65 @@
-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 Version230To2101
+        def self.applicable_to?(mini_test_version)
+          Gem::Requirement.new('>= 2.3.0', '<= 2.10.1').satisfied_by?(mini_test_version)
+        end
+
+        def self.description
+          "monkey patch for MiniTest gem >= v2.3.0 <= v2.10.1"
+        end
+
         def self.included(mod)
-          $stderr.puts "Monkey patching MiniTest >= v2.3.0 <= v2.10.1" if $mocha_options['debug']
+          MonkeyPatcher.apply(mod, RunMethodPatch)
         end
-        def run runner
-          trap 'INFO' do
-            time = runner.start_time ? Time.now - runner.start_time : 0
-            warn "%s#%s %.2fs" % [self.class, self.__name__, time]
-            runner.status $stderr
-          end if ::MiniTest::Unit::TestCase::SUPPORTS_INFO_SIGNAL
 
-          assertion_counter = AssertionCounter.new(self)
-          result = ""
-          begin
+        module RunMethodPatch
+          def run runner
+            trap 'INFO' do
+              time = runner.start_time ? Time.now - runner.start_time : 0
+              warn "%s#%s %.2fs" % [self.class, self.__name__, time]
+              runner.status $stderr
+            end if ::MiniTest::Unit::TestCase::SUPPORTS_INFO_SIGNAL
+
+            assertion_counter = AssertionCounter.new(self)
+            result = ""
             begin
-              @passed = nil
-              self.setup
-              self.run_setup_hooks
-              self.__send__ self.__name__
-              mocha_verify(assertion_counter)
-              result = "." unless io?
-              @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.run_teardown_hooks
-                self.teardown
+                @passed = nil
+                self.setup
+                self.run_setup_hooks
+                self.__send__ self.__name__
+                mocha_verify(assertion_counter)
+                result = "." unless io?
+                @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.run_teardown_hooks
+                  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' if ::MiniTest::Unit::TestCase::SUPPORTS_INFO_SIGNAL
               end
-              trap 'INFO', 'DEFAULT' if ::MiniTest::Unit::TestCase::SUPPORTS_INFO_SIGNAL
+            ensure
+              mocha_teardown
             end
-          ensure
-            mocha_teardown
+            result
           end
-          result
         end
       end
-
     end
-
   end
-
 end

data/lib/mocha/integration/mini_test.rb

@@ -1,68 +1,53 @@
-require 'mocha/api'
-require 'mocha/options'
-
-if !MiniTest::Unit::TestCase.ancestors.include?(Mocha::API)
-
-  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_to_172'
-  require 'mocha/integration/mini_test/version_200'
-  require 'mocha/integration/mini_test/version_201_to_222'
-  require 'mocha/integration/mini_test/version_230_to_2101'
-  require 'mocha/integration/mini_test/version_2110_to_2111'
-  require 'mocha/integration/mini_test/version_2112_to_320'
-  require 'mocha/integration/mini_test/version_330_to_410'
-  require 'mocha/integration/mini_test/version_420_to_433'
-  require 'mocha/integration/mini_test/version_440'
-
-  module MiniTest
-    class Unit
-      class TestCase
-
-        include Mocha::API
-
-        alias_method :run_before_mocha, :run
-        remove_method :run
+require 'mocha/debug'
+
+require 'mocha/integration/mini_test/nothing'
+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_to_172'
+require 'mocha/integration/mini_test/version_200'
+require 'mocha/integration/mini_test/version_201_to_222'
+require 'mocha/integration/mini_test/version_230_to_2101'
+require 'mocha/integration/mini_test/version_2110_to_2111'
+require 'mocha/integration/mini_test/version_2112_to_320'
+require 'mocha/integration/mini_test/adapter'
+
+module Mocha
+  module Integration
+    module MiniTest
+      def self.activate
+        return false unless defined?(::MiniTest::Unit::TestCase)
 
         mini_test_version = begin
-          Gem::Version.new(MiniTest::Unit::VERSION)
+          Gem::Version.new(::MiniTest::Unit::VERSION)
         rescue LoadError
           Gem::Version.new('0.0.0')
         end
 
-        $stderr.puts "Detected MiniTest version: #{mini_test_version}" if $mocha_options['debug']
-
-        if Gem::Requirement.new('>= 1.3.0', '<= 1.3.1').satisfied_by?(mini_test_version)
-          include Mocha::Integration::MiniTest::Version13
-        elsif Gem::Requirement.new('1.4.0').satisfied_by?(mini_test_version)
-          include Mocha::Integration::MiniTest::Version140
-        elsif Gem::Requirement.new('1.4.1').satisfied_by?(mini_test_version)
-          include Mocha::Integration::MiniTest::Version141
-        elsif Gem::Requirement.new('>= 1.4.2', '<= 1.7.2').satisfied_by?(mini_test_version)
-          include Mocha::Integration::MiniTest::Version142To172
-        elsif Gem::Requirement.new('2.0.0').satisfied_by?(mini_test_version)
-          include Mocha::Integration::MiniTest::Version200
-        elsif Gem::Requirement.new('>= 2.0.1', '<= 2.2.2').satisfied_by?(mini_test_version)
-          include Mocha::Integration::MiniTest::Version201To222
-        elsif Gem::Requirement.new('>= 2.3.0', '<= 2.10.1').satisfied_by?(mini_test_version)
-          include Mocha::Integration::MiniTest::Version230To2101
-        elsif Gem::Requirement.new('>= 2.11.0', '<= 2.11.1').satisfied_by?(mini_test_version)
-          include Mocha::Integration::MiniTest::Version2110To2111
-        elsif Gem::Requirement.new('>= 2.11.2', '<= 3.2.0').satisfied_by?(mini_test_version)
-          include Mocha::Integration::MiniTest::Version2112To320
-        elsif Gem::Requirement.new('>= 3.3.0', '<= 4.1.0').satisfied_by?(mini_test_version)
-          include Mocha::Integration::MiniTest::Version330To410
-        elsif Gem::Requirement.new('>= 4.2.0', '<= 4.3.3').satisfied_by?(mini_test_version)
-          include Mocha::Integration::MiniTest::Version420To433
-        elsif Gem::Requirement.new('>= 4.4.0', '<= 4.4.0').satisfied_by?(mini_test_version)
-          include Mocha::Integration::MiniTest::Version440
-        else
-          raise "No Mocha monkey-patch for MiniTest version"
+        Debug.puts "Detected MiniTest version: #{mini_test_version}"
+
+        integration_module = [
+          MiniTest::Adapter,
+          MiniTest::Version2112To320,
+          MiniTest::Version2110To2111,
+          MiniTest::Version230To2101,
+          MiniTest::Version201To222,
+          MiniTest::Version200,
+          MiniTest::Version142To172,
+          MiniTest::Version141,
+          MiniTest::Version140,
+          MiniTest::Version13,
+          MiniTest::Nothing
+        ].detect { |m| m.applicable_to?(mini_test_version) }
+
+        unless ::MiniTest::Unit::TestCase < integration_module
+          Debug.puts "Applying #{integration_module.description}"
+          ::MiniTest::Unit::TestCase.send(:include, integration_module)
         end
-
       end
+      true
     end
   end
 end
+
+

data/lib/mocha/integration/monkey_patcher.rb

@@ -0,0 +1,18 @@
+require 'mocha/api'
+
+module Mocha
+  module Integration
+    module MonkeyPatcher
+      def self.apply(mod, run_method_patch)
+        unless mod < Mocha::API
+          mod.send(:include, Mocha::API)
+        end
+        unless mod.method_defined?(:run_before_mocha)
+          mod.send(:alias_method, :run_before_mocha, :run)
+          mod.send(:remove_method, :run)
+          mod.send(:include, run_method_patch)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+require 'mocha/api'
+require 'mocha/integration/assertion_counter'
+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.
+      module Adapter
+        include Mocha::API
+
+        # @private
+        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"
+        end
+
+        # @private
+        def self.included(mod)
+          mod.setup :mocha_setup, :before => :prepend
+
+          mod.exception_handler(:handle_mocha_expectation_error)
+
+          mod.cleanup :after => :append do
+            assertion_counter = Integration::AssertionCounter.new(self)
+            mocha_verify(assertion_counter)
+          end
+
+          mod.teardown :mocha_teardown, :after => :append
+        end
+
+        private
+
+        # @private
+        def handle_mocha_expectation_error(e)
+          return false unless e.is_a?(Mocha::ExpectationError)
+          problem_occurred
+          add_failure(e.message, e.backtrace)
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -1,52 +1,59 @@
-require 'test/unit/testcase'
-require 'mocha/integration/test_unit/assertion_counter'
+require 'mocha/integration/assertion_counter'
+require 'mocha/integration/monkey_patcher'
 require 'mocha/expectation_error'
 
 module Mocha
-
   module Integration
-
     module TestUnit
-
       module GemVersion200
+        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"
+        end
+
         def self.included(mod)
-          $stderr.puts "Monkey patching Test::Unit gem v2.0.0" if $mocha_options['debug']
+          MonkeyPatcher.apply(mod, RunMethodPatch)
         end
-        def run(result)
-          assertion_counter = AssertionCounter.new(result)
-          begin
-            @_result = result
-            yield(Test::Unit::TestCase::STARTED, name)
+
+        module RunMethodPatch
+          def run(result)
+            assertion_counter = AssertionCounter.new(self)
             begin
+              @_result = result
+              yield(Test::Unit::TestCase::STARTED, name)
               begin
-                run_setup
-                __send__(@method_name)
-                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
+                  run_setup
+                  __send__(@method_name)
+                  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 Mocha::ExpectationError => e
+                    add_failure(e.message, e.backtrace)
+                  rescue Exception
+                    raise unless handle_exception($!)
+                  end
                 end
+              ensure
+                mocha_teardown
               end
+              result.add_run
+              yield(Test::Unit::TestCase::FINISHED, name)
             ensure
-              mocha_teardown
+              @_result = nil
             end
-            result.add_run
-            yield(Test::Unit::TestCase::FINISHED, name)
-          ensure
-            @_result = nil
           end
         end
       end
-
     end
-
   end
-
 end

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

@@ -1,52 +1,59 @@
-require 'test/unit/testcase'
-require 'mocha/integration/test_unit/assertion_counter'
+require 'mocha/integration/assertion_counter'
+require 'mocha/integration/monkey_patcher'
 require 'mocha/expectation_error'
 
 module Mocha
-
   module Integration
-
     module TestUnit
-
       module GemVersion201To202
+        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"
+        end
+
         def self.included(mod)
-          $stderr.puts "Monkey patching Test::Unit gem >= v2.0.1 and <= v2.0.2" if $mocha_options['debug']
+          MonkeyPatcher.apply(mod, RunMethodPatch)
         end
-        def run(result)
-          assertion_counter = AssertionCounter.new(result)
-          begin
-            @_result = result
-            yield(Test::Unit::TestCase::STARTED, name)
+
+        module RunMethodPatch
+          def run(result)
+            assertion_counter = AssertionCounter.new(self)
             begin
+              @_result = result
+              yield(Test::Unit::TestCase::STARTED, name)
               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
+                  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 Mocha::ExpectationError => e
+                    add_failure(e.message, e.backtrace)
+                  rescue Exception
+                    raise unless handle_exception($!)
+                  end
                 end
+              ensure
+                mocha_teardown
               end
+              result.add_run
+              yield(Test::Unit::TestCase::FINISHED, name)
             ensure
-              mocha_teardown
+              @_result = nil
             end
-            result.add_run
-            yield(Test::Unit::TestCase::FINISHED, name)
-          ensure
-            @_result = nil
           end
         end
       end
-
     end
-
   end
-
 end

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

@@ -1,52 +1,59 @@
-require 'test/unit/testcase'
-require 'mocha/integration/test_unit/assertion_counter'
+require 'mocha/integration/assertion_counter'
+require 'mocha/integration/monkey_patcher'
 require 'mocha/expectation_error'
 
 module Mocha
-
   module Integration
-
     module TestUnit
-
       module GemVersion203To220
+        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"
+        end
+
         def self.included(mod)
-          $stderr.puts "Monkey patching Test::Unit gem >= v2.0.3 and <= v2.2.0" if $mocha_options['debug']
+          MonkeyPatcher.apply(mod, RunMethodPatch)
         end
-        def run(result)
-          assertion_counter = AssertionCounter.new(result)
-          begin
-            @_result = result
-            yield(Test::Unit::TestCase::STARTED, name)
+
+        module RunMethodPatch
+          def run(result)
+            assertion_counter = AssertionCounter.new(self)
             begin
+              @_result = result
+              yield(Test::Unit::TestCase::STARTED, name)
               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
+                  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 Mocha::ExpectationError => e
+                    add_failure(e.message, e.backtrace)
+                  rescue Exception
+                    raise unless handle_exception($!)
+                  end
                 end
+              ensure
+                mocha_teardown
               end
+              result.add_run
+              yield(Test::Unit::TestCase::FINISHED, name)
             ensure
-              mocha_teardown
+              # @_result = nil # For test-spec's after_all :<
             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/gem_version_230_to_250.rb

@@ -0,0 +1,65 @@
+require 'mocha/integration/assertion_counter'
+require 'mocha/integration/monkey_patcher'
+require 'mocha/expectation_error'
+
+module Mocha
+  module Integration
+    module TestUnit
+      module GemVersion230To250
+        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"
+        end
+
+        def self.included(mod)
+          MonkeyPatcher.apply(mod, RunMethodPatch)
+        end
+
+        module RunMethodPatch
+          def run(result)
+            assertion_counter = AssertionCounter.new(self)
+            begin
+              @internal_data.test_started
+              @_result = result
+              yield(Test::Unit::TestCase::STARTED, name)
+              yield(Test::Unit::TestCase::STARTED_OBJECT, self)
+              begin
+                begin
+                  run_setup
+                  run_test
+                  run_cleanup
+                  mocha_verify(assertion_counter)
+                  add_pass
+                rescue Mocha::ExpectationError => e
+                  add_failure(e.message, e.backtrace)
+                rescue Exception
+                  @internal_data.interrupted
+                  raise unless handle_exception($!)
+                ensure
+                  begin
+                    run_teardown
+                  rescue Mocha::ExpectationError => e
+                    add_failure(e.message, e.backtrace)
+                  rescue Exception
+                    raise unless handle_exception($!)
+                  end
+                end
+              ensure
+                mocha_teardown
+              end
+              @internal_data.test_finished
+              result.add_run
+              yield(Test::Unit::TestCase::FINISHED, name)
+              yield(Test::Unit::TestCase::FINISHED_OBJECT, self)
+            ensure
+              # @_result = nil # For test-spec's after_all :<
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Mocha
+  module Integration
+    module TestUnit
+      module Nothing
+        def self.applicable_to?(test_unit_version, ruby_version = nil)
+          true
+        end
+
+        def self.description
+          "nothing (no Test::Unit integration available)"
+        end
+
+        def self.included(mod)
+          raise "No Test::Unit integration available"
+        end
+      end
+    end
+  end
+end