minirunner.rb in turn-0.8.2

- old
+ new

@@ -1,6 +1,6 @@
-#
+require 'stringio'
 
 # Becuase of some wierdness in MiniTest
 debug, $DEBUG = $DEBUG, false
 require 'minitest/unit'
 $DEBUG = debug
@@ -11,12 +11,13 @@
 
   # = MiniTest TestRunner
   #
   class MiniRunner < ::MiniTest::Unit
 
-    #
+    # Override initialize to take controller argument.
     def initialize(controller)
+      @turn_controller = controller
 
       controller.loadpath.each{ |path| $: << path } unless controller.live?
       controller.requires.each{ |path| require(path) }
 
       [controller.files].flatten.each{ |path| require(path) }
@@ -42,148 +43,123 @@
       #end
 
       @turn_logger = controller.reporter
 
       super()
+
+      # route minitests traditional output to nowhere
+      # (instead of overriding #puts and #print)
+      @@out = ::StringIO.new
     end
 
-    #
+    # Turn calls this method to start the test run.
     def start(args=[])
       run(args)
       return @turn_suite
     end
 
-    #
-    def run(args = [])
-      @verbose = true
+    # Override #_run_suite to setup Turn.
+    def _run_suites suites, type
+      @turn_suite = Turn::TestSuite.new(@turn_suite_name)
+      @turn_suite.size = ::MiniTest::Unit::TestCase.test_suites.size
 
-      filter = if args.first =~ /^(-n|--name)$/ then
-                 args.shift
-                 arg = args.shift
-                 arg =~ /\/(.*)\// ? Regexp.new($1) : arg
-               else
-                 /./ # anything - ^test_ already filtered by #tests
-               end
+      @turn_logger.start_suite(@turn_suite)
 
-      #@@out.puts "Loaded suite #{$0.sub(/\.rb$/, '')}\nStarted"
+      if @turn_controller.matchcase
+        suites = suites.select{ |suite| @turn_controller.matchcase =~ suite.name }
+      end
 
-      start = Time.now
+      result = suites.map { |suite| _run_suite(suite, type) }
 
-      run_test_suites(filter)
+      @turn_logger.finish_suite(@turn_suite)
 
-      return failures + errors if @test_count > 0 # or return nil...
+      return result
     end
 
-    #
-    def run_test_suites(filter = /./)
-      @test_count, @assertion_count = 0, 0
-      old_sync, @@out.sync = @@out.sync, true if @@out.respond_to? :sync=
+    # Override #_run_suite to iterate tests via Turn.
+    def _run_suite suite, type
+      # suites are cases in minitest
+      @turn_case = @turn_suite.new_case(suite.name)
 
-      @turn_suite = Turn::TestSuite.new(@turn_suite_name)
-      @turn_suite.size = ::MiniTest::Unit::TestCase.test_suites.size
-      @turn_logger.start_suite(@turn_suite)
+      filter = @turn_controller.pattern || /./
 
-      ::MiniTest::Unit::TestCase.test_suites.each do |kase|
+      suite.send("#{type}_methods").grep(filter).each do |test|
+        @turn_case.new_test(test)
+      end
 
-        test_cases = kase.test_methods.grep(filter)
+      @turn_logger.start_case(@turn_case)
 
-        @turn_case = @turn_suite.new_case(kase.name)
+      header = "#{type}_suite_header"
+      puts send(header, suite) if respond_to? header
 
-        turn_cases = test_cases.map do |test|
-          @turn_case.new_test(test)
-        end
+      assertions = @turn_case.tests.map do |test|
+        @turn_test = test
+        @turn_logger.start_test(@turn_test)
 
-        @turn_logger.start_case(@turn_case)
+        inst = suite.new(test.name) #method
+        inst._assertions = 0
 
-        turn_cases.each do |test|
-          #methname, tcase = name.scan(%r/^([^\(]+)\(([^\)]+)\)/o).flatten!
-          @turn_test = test #@turn_case.new_test(test)
-          @turn_logger.start_test(@turn_test)
+        result = inst.run self
 
-          inst = kase.new(test.name)
-          inst._assertions = 0
+        if result == "."
+          @turn_logger.pass
+        end
 
-          result = inst.run(self)
-          report = @report.last
+        @turn_logger.finish_test(@turn_test)
 
-          case result
-          when :pass
-            @turn_logger.pass
-          when :error
-            #trace = ::MiniTest::filter_backtrace(report[:exception].backtrace).first
-            @turn_test.error!(report)
-            @turn_logger.error(report)
-          when :fail
-            #trace = ::MiniTest::filter_backtrace(report[:exception].backtrace).first
-            @turn_test.fail!(report)
-            @turn_logger.fail(report)
-          when :skip
-            @turn_test.skip! #(report)
-            @turn_logger.skip #(report)
-          end
+        inst._assertions
+      end
 
-          @turn_logger.finish_test(@turn_test)
+      @turn_case.count_assertions = assertions.inject(0) { |sum, n| sum + n }
 
-          @test_count += 1
-          @assertion_count += inst._assertions
-        end
-        @turn_case.count_assertions = @assertion_count  # for lack of a better appraoch
-        @turn_logger.finish_case(@turn_case)
+      @turn_logger.finish_case(@turn_case)
+
+      return assertions.size, assertions.inject(0) { |sum, n| sum + n }
+    end
+
+    # Override #puke to update Turn's internals and reporter.
+    def puke(klass, meth, err)
+      case err
+      when MiniTest::Skip
+        @turn_test.skip!
+        @turn_logger.skip #(e)
+      when MiniTest::Assertion
+        @turn_test.fail!(err)
+        @turn_logger.fail(err)
+      else
+        @turn_test.error!(err)
+        @turn_logger.error(err)
       end
-      @turn_logger.finish_suite(@turn_suite)
-      @@out.sync = old_sync if @@out.respond_to? :sync=
-      [@test_count, @assertion_count]
+      super(klass, meth, err)
     end
 
-    # Overwrite #puke method so that is stores a hash
-    # with :message and :exception keys.
-    def puke(klass, meth, e)
-      result = nil
-      msg = case e
-          when ::MiniTest::Skip
-            @skips += 1
-            result = :skip
-            e.message
-          when ::MiniTest::Assertion
-            @failures += 1
-            result = :fail
-            e.message
-          else
-            @errors += 1
-            result = :error
-            "#{e.class}: #{e.message}\n"
-          end
+    # To maintain compatibility with old versions of MiniTest.
+    if ::MiniTest::Unit::VERSION < '2.0'
 
-      @report << e #{:message => msg, :exception => e}
-      result
-    end
+      #attr_accessor :options
 
-  end
+      #
+      def run(args=[])
+        suites = ::MiniTest::Unit::TestCase.test_suites
+        return if suites.empty?
 
-end
+        @test_count, @assertion_count = 0, 0
+        sync = @@out.respond_to? :"sync=" # stupid emacs
+        old_sync, @@out.sync = @@out.sync, true if sync
 
-class ::MiniTest::Unit::TestCase
-  old_verbose, $VERBOSE = $VERBOSE, false
-  # Overwrite #run method so that is uses symbols
-  # as return values rather than characters.
-  def run(runner)
-    result = :pass
-    begin
-      @passed = nil
-      self.setup
-      self.__send__(self.__name__.to_s)
-      @passed = true
-    rescue Exception => e
-      @passed = false
-      result = runner.puke(self.class, self.__name__.to_s, e)
-    ensure
-      begin
-        self.teardown
-      rescue Exception => e
-        result = runner.puke(self.class, self.__name__.to_s, e)
+        results = _run_suites suites, :test #type
+
+        @test_count      = results.inject(0) { |sum, (tc, _)| sum + tc }
+        @assertion_count = results.inject(0) { |sum, (_, ac)| sum + ac }
+
+        @@out.sync = old_sync if sync
+
+        return failures + errors if @test_count > 0 # or return nil...
+      rescue Interrupt
+        abort 'Interrupted'
       end
+
     end
-    result
+
   end
-  $VERBOSE = old_verbose
-end
 
+end