mocha 0.10.5 → 1.13.0

data/lib/mocha/integration/mini_test.rb

@@ -1,53 +1,55 @@
-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_262'
-
-  module MiniTest
-    class Unit
-      class TestCase
-
-        include Mocha::API
-
-        alias_method :run_before_mocha, :run
-        remove_method :run
-
-        mini_test_version = begin
-          Gem::Version.new(MiniTest::Unit::VERSION)
-        rescue LoadError
-          Gem::Version.new('0.0.0')
+require 'mocha/debug'
+
+require 'mocha/detection/mini_test'
+
+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'
+
+require 'mocha/deprecation'
+
+module Mocha
+  module Integration
+    module MiniTest
+      def self.activate
+        return false unless Detection::MiniTest.testcase
+        mini_test_version = Gem::Version.new(Detection::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) }
+
+        target = Detection::MiniTest.testcase
+        unless target < integration_module
+          unless integration_module == MiniTest::Adapter
+            Deprecation.warning(
+              'Versions of minitest earlier than v3.3.0 will not be supported in future versions of Mocha.'
+            )
+          end
+          Debug.puts "Applying #{integration_module.description}"
+          target.send(:include, integration_module)
         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').satisfied_by?(mini_test_version)
-          $stderr.puts "*** MiniTest integration has not been verified but patching anyway ***" if (Gem::Requirement.new('> 2.6.2').satisfied_by?(mini_test_version)) && $mocha_options['debug']
-          include Mocha::Integration::MiniTest::Version230To262
-        else
-          $stderr.puts "*** No Mocha integration for MiniTest version ***" if $mocha_options['debug']
-        end
-
+        true
       end
     end
   end

data/lib/mocha/integration/monkey_patcher.rb

@@ -0,0 +1,24 @@
+require 'mocha/api'
+
+module Mocha
+  module Integration
+    module MonkeyPatcher
+      def self.apply(mod, run_method_patch)
+        if mod < Mocha::API
+          Debug.puts "Mocha::API already included in #{mod}"
+        else
+          mod.send(:include, Mocha::API)
+        end
+        if mod.method_defined?(:run_before_mocha)
+          Debug.puts "#{mod}#run_before_mocha method already defined"
+        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,50 @@
+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(exception)
+          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/gem_version_200.rb

@@ -1,52 +1,62 @@
-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
+          # rubocop:disable all
+          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
+                  mocha_setup
+                  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
+          # rubocop:enable all
         end
       end
-      
     end
-    
   end
-  
 end

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

@@ -1,52 +1,62 @@
-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
+          # rubocop:disable all
+          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
+                  mocha_setup
+                  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
+          # rubocop:enable all
         end
       end
-      
     end
-    
   end
-  
 end

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

@@ -1,52 +1,62 @@
-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
+          # rubocop:disable all
+          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
+                  mocha_setup
+                  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
+          # rubocop:enable all
         end
       end
-
     end
-
   end
-
 end

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

@@ -0,0 +1,68 @@
+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
+          # rubocop:disable all
+          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
+                  mocha_setup
+                  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
+          # rubocop:enable all
+        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

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

@@ -1,51 +1,61 @@
-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 RubyVersion185AndBelow
+        def self.applicable_to?(test_unit_version, ruby_version)
+          Gem::Requirement.new('<= 1.2.3').satisfied_by?(test_unit_version) && Gem::Requirement.new('<= 1.8.5').satisfied_by?(ruby_version)
+        end
+
+        def self.description
+          'monkey patch for standard library in Ruby <= v1.8.5'
+        end
+
         def self.included(mod)
-          $stderr.puts "Monkey patching Test::Unit for Ruby <= v1.8.5" if $mocha_options['debug']
+          MonkeyPatcher.apply(mod, RunMethodPatch)
         end
-        def run(result)
-          assertion_counter = AssertionCounter.new(result)
-          yield(Test::Unit::TestCase::STARTED, name)
-          @_result = result
-          begin
+
+        module RunMethodPatch
+          # rubocop:disable all
+          def run(result)
+            assertion_counter = AssertionCounter.new(self)
+            yield(Test::Unit::TestCase::STARTED, name)
+            @_result = result
             begin
-              setup
-              __send__(@method_name)
-              mocha_verify(assertion_counter)
-            rescue Mocha::ExpectationError => e
-              add_failure(e.message, e.backtrace)
-            rescue Test::Unit::AssertionFailedError => e
-              add_failure(e.message, e.backtrace)
-            rescue StandardError, ScriptError
-              add_error($!)
-            ensure
               begin
-                teardown
+                mocha_setup
+                setup
+                __send__(@method_name)
+                mocha_verify(assertion_counter)
+              rescue Mocha::ExpectationError => e
+                add_failure(e.message, e.backtrace)
               rescue Test::Unit::AssertionFailedError => e
                 add_failure(e.message, e.backtrace)
               rescue StandardError, ScriptError
                 add_error($!)
+              ensure
+                begin
+                  teardown
+                rescue Mocha::ExpectationError => e
+                  add_failure(e.message, e.backtrace)
+                rescue Test::Unit::AssertionFailedError => e
+                  add_failure(e.message, e.backtrace)
+                rescue StandardError, ScriptError
+                  add_error($!)
+                end
               end
+            ensure
+              mocha_teardown
             end
-          ensure
-            mocha_teardown
+            result.add_run
+            yield(Test::Unit::TestCase::FINISHED, name)
           end
-          result.add_run
-          yield(Test::Unit::TestCase::FINISHED, name)
+          # rubocop:enable all
         end
       end
-      
     end
-    
   end
-  
 end