minitest-reporters 0.14.24 → 1.0.0.beta1

data/lib/minitest/reporters/junit_reporter.rb

@@ -1,7 +1,7 @@
 require 'ansi/code'
 require 'builder'
 require 'fileutils'
-module MiniTest
+module Minitest
   module Reporters
     # A reporter for writing JUnit test reports
     # Intended for easy integration with CI servers - tested on JetBrains TeamCity
@@ -9,10 +9,9 @@ module MiniTest
     # Inspired by ci_reporter (see https://github.com/nicksieger/ci_reporter)
     # Also inspired by Marc Seeger's attempt at producing a JUnitReporter (see https://github.com/rb2k/minitest-reporters/commit/e13d95b5f884453a9c77f62bc5cba3fa1df30ef5)
     # Also inspired by minitest-ci (see https://github.com/bhenderson/minitest-ci)
-    class JUnitReporter
-      include Reporter
-
+    class JUnitReporter < BaseReporter
       def initialize(reports_dir = "test/reports", empty = true)
+        super({})
         @reports_path = File.absolute_path(reports_dir)
 
         if empty
@@ -22,20 +21,24 @@ module MiniTest
         end
       end
 
-      def after_suites(suites, type)
+      def report
+        super
+
         puts "Writing XML reports to #{@reports_path}"
-        runner.test_results.each do |suite, tests|
-          suite_result = analyze_suite(suite, tests)
+        suites = tests.group_by(&:class)
+
+        suites.each do |suite, tests|
+          suite_result = analyze_suite(tests)
 
           xml = Builder::XmlMarkup.new(:indent => 2)
           xml.instruct!
-          xml.testsuite(:name => suite, :skipped => suite_result[:skip_count], :failures => suite_result[:failure_count],
+          xml.testsuite(:name => suite, :skipped => suite_result[:skip_count], :failures => suite_result[:fail_count],
                         :errors => suite_result[:error_count], :tests => suite_result[:test_count],
                         :assertions => suite_result[:assertion_count], :time => suite_result[:time]) do
-            tests.each do |test, test_runner|
-              xml.testcase(:name => test_runner.test.to_s, :classname => suite, :assertions => test_runner.assertions,
-                           :time => test_runner.time) do
-                xml << xml_message_for(test_runner) if test_runner.result != :pass
+            tests.each do |test|
+              xml.testcase(:name => test.name, :classname => suite, :assertions => test.assertions,
+                           :time => test.time) do
+                xml << xml_message_for(test) unless test.passed?
               end
             end
           end
@@ -45,7 +48,7 @@ module MiniTest
 
       private
 
-      def xml_message_for(test_runner)
+      def xml_message_for(test)
         # This is a trick lifted from ci_reporter
         xml = Builder::XmlMarkup.new(:indent => 2, :margin => 2)
 
@@ -53,42 +56,38 @@ module MiniTest
           txt.sub(/\n.*/m, '...')
         end
 
-        test = test_runner.test
-        e = test_runner.exception
+        e = test.failure
 
-        case test_runner.result
-        when :skip
-          xml.skipped(:type => test)
-        when :error
-          xml.error(:type => test, :message => xml.trunc!(e.message)) do
-            xml.text!(message_for(test_runner))
+        if test.skipped?
+          xml.skipped(:type => test.name)
+        elsif test.error?
+          xml.error(:type => test.name, :message => xml.trunc!(e.message)) do
+            xml.text!(message_for(test))
           end
-        when :failure
-          xml.failure(:type => test, :message => xml.trunc!(e.message)) do
-            xml.text!(message_for(test_runner))
+        elsif test.failure
+          xml.failure(:type => test.name, :message => xml.trunc!(e.message)) do
+            xml.text!(message_for(test))
           end
         end
       end
 
-      def message_for(test_runner)
-        suite = test_runner.suite
-        test = test_runner.test
-        e = test_runner.exception
+      def message_for(test)
+        suite = test.class
+        name = test.name
+        e = test.failure
 
-        case test_runner.result
-        when :pass then
+        if test.passed?
           nil
-        when :skip then
-          "Skipped:\n#{test}(#{suite}) [#{location(e)}]:\n#{e.message}\n"
-        when :failure then
-          "Failure:\n#{test}(#{suite}) [#{location(e)}]:\n#{e.message}\n"
-        when :error
-          bt = filter_backtrace(test_runner.exception.backtrace).join "\n    "
-          "Error:\n#{test}(#{suite}):\n#{e.class}: #{e.message}\n    #{bt}\n"
+        elsif test.skipped?
+          "Skipped:\n#{name}(#{suite}) [#{location(e)}]:\n#{e.message}\n"
+        elsif test.failure
+          "Failure:\n#{name}(#{suite}) [#{location(e)}]:\n#{e.message}\n"
+        elsif test.error?
+          bt = filter_backtrace(test.exception.backtrace).join "\n    "
+          "Error:\n#{name}(#{suite}):\n#{e.class}: #{e.message}\n    #{bt}\n"
         end
       end
 
-
       def location(exception)
         last_before_assertion = ''
         exception.backtrace.reverse_each do |s|
@@ -98,13 +97,13 @@ module MiniTest
         last_before_assertion.sub(/:in .*$/, '')
       end
 
-      def analyze_suite(suite, tests)
+      def analyze_suite(tests)
         result = Hash.new(0)
-        tests.each do |test, test_runner|
-          result[:"#{test_runner.result}_count"] += 1
-          result[:assertion_count] += test_runner.assertions
+        tests.each do |test|
+          result[:"#{result(test)}_count"] += 1
+          result[:assertion_count] += test.assertions
           result[:test_count] += 1
-          result[:time] += test_runner.time
+          result[:time] += test.time
         end
         result
       end

data/lib/minitest/reporters/progress_reporter.rb

@@ -1,7 +1,7 @@
 require 'ansi/code'
 require 'powerbar'
 
-module MiniTest
+module Minitest
   module Reporters
     # Fuubar-like reporter with a progress bar.
     #
@@ -10,16 +10,17 @@ module MiniTest
     #
     # @see https://github.com/jeffkreeftmeijer/fuubar Fuubar
     # @see https://gist.github.com/356945 paydro's monkey-patch
-    class ProgressReporter
-      include Reporter
+    class ProgressReporter < BaseReporter
+      include RelativePosition
       include ANSI::Code
 
       INFO_PADDING = 2
 
       def initialize(options = {})
+        super
         @detailed_skip = options.fetch(:detailed_skip, true)
 
-        @progress = PowerBar.new(:msg => "0/#{runner.test_count}")
+        @progress = PowerBar.new(:msg => "0/#{count}")
         @progress.settings.tty.finite.output = lambda { |s| print(s) }
         @progress.settings.tty.finite.template.barchar = "="
         @progress.settings.tty.finite.template.padchar = " "
@@ -27,102 +28,65 @@ module MiniTest
         @progress.settings.tty.finite.template.post = CLEAR
       end
 
-      def before_suites(suites, type)
+      def start
+        super
         puts 'Started'
         puts
-
-        @finished_count = 0
         show
       end
 
-      def increment
-        @finished_count += 1
-        show
-      end
-
-      def show
-        return if runner.test_count == 0
-
-        @progress.show({
-          :msg => "#{@finished_count}/#{runner.test_count}",
-          :done => @finished_count,
-          :total => runner.test_count,
-        }, true)
-      end
-
-      def after_test(suite, test)
-        increment
-      end
-
-      def skip(suite, test, test_runner)
-        if @detailed_skip
+      def record(test)
+        super
+        if (test.skipped? && @detailed_skip) || test.failure
           wipe
-          print(yellow { 'SKIP' })
-          print_test_with_time(suite, test)
+          print(yellow { result(test).to_s.upcase })
+          print_test_with_time(test)
           puts
+          print_info(test.failure, test.error?) if test.failure
           puts
         end
 
-        self.color = YELLOW unless color == RED
-      end
-
-      def failure(suite, test, test_runner)
-        wipe
-        print(red { 'FAIL' })
-        print_test_with_time(suite, test)
-        puts
-        print_info(test_runner.exception, false)
-        puts
-
-        self.color = RED
-      end
-
-      def error(suite, test, test_runner)
-        wipe
-        print(red { 'ERROR' })
-        print_test_with_time(suite, test)
-        puts
-        print_info(test_runner.exception)
-        puts
+        if test.skipped? && color != RED
+          self.color = YELLOW
+        elsif test.failure
+          self.color = RED
+        end
 
-        self.color = RED
+        show
       end
 
-      def after_suites(suites, type)
+      def report
+        super
         @progress.close
 
-        total_time = Time.now - runner.suites_start_time
-
         wipe
         puts
         puts('Finished in %.5fs' % total_time)
-        print('%d tests, %d assertions, ' % [runner.test_count, runner.assertion_count])
-        print(red { '%d failures, %d errors, ' } % [runner.failures, runner.errors])
-        print(yellow { '%d skips' } % runner.skips)
+        print('%d tests, %d assertions, ' % [count, assertions])
+        print(red { '%d failures, %d errors, ' } % [failures, errors])
+        print(yellow { '%d skips' } % skips)
         puts
       end
 
       private
 
-      def wipe
-        @progress.wipe
-      end
+      def show
+        return if count == 0
 
-      def print_test_with_time(suite, test)
-        total_time = Time.now - (runner.test_start_time || Time.now)
-        print(" %s#%s (%.2fs)%s" % [suite, test, total_time, clr])
+        @progress.show({
+          :msg => "#{total_count}/#{count}",
+          :done => count,
+          :total => total_count,
+        }, true)
       end
 
-      def print_info(e, name = true)
-        print pad("#{e.exception.class.to_s}: ") if name
-        e.message.each_line { |line| puts pad(line) }
-
-        trace = filter_backtrace(e.backtrace)
-        trace.each { |line| puts pad(line) }
+      def wipe
+        @progress.wipe
       end
 
-      def pad(str)
-        ' ' * INFO_PADDING + str
+      def print_test_with_time(test)
+        puts [test.name, test.class, total_time, ENDCODE].inspect
+        print(" %s#%s (%.2fs)%s" % [test.name, test.class, total_time, ENDCODE])
       end
 
       def color

data/lib/minitest/reporters/ruby_mate_reporter.rb

@@ -1,69 +1,55 @@
 require 'ansi/code'
 
-module MiniTest
+module Minitest
   module Reporters
     # Simple reporter designed for RubyMate.
-    class RubyMateReporter
-      include Reporter
+    class RubyMateReporter < BaseReporter
+      include RelativePosition
 
       INFO_PADDING = 2
 
-      def before_suites(suites, type)
+      def start
+        super
         puts 'Started'
         puts
       end
 
-      def skip(suite, test, test_runner)
-        print 'SKIP'
-        print_test_with_time(suite, test)
-        puts
-        puts
-      end
-
-      def failure(suite, test, test_runner)
-        print 'FAIL'
-        print_test_with_time(suite, test)
-        puts
-        print_info(test_runner.exception, false)
-        puts
-      end
-
-      def error(suite, test, test_runner)
-        print 'ERROR'
-        print_test_with_time(suite, test)
-        puts
-        print_info(test_runner.exception)
-        puts
-      end
-
-      def after_suites(suites, type)
-        total_time = Time.now - runner.suites_start_time
-
+      def record(test)
+        super
+        if test.skipped?
+          print 'SKIP'
+          print_test_with_time(test)
+          puts
+          puts
+        elsif test.error?
+          print 'ERROR'
+          print_test_with_time(test)
+          puts
+          print_info(test.failure)
+          puts
+        elsif test.failure
+          print 'FAIL'
+          print_test_with_time(test)
+          puts
+          print_info(test.failure, false)
+          puts
+        end
+      end
+
+      def report
+        super
         puts
         puts('Finished in %.5fs' % total_time)
-        print('%d tests, %d assertions, ' % [runner.test_count, runner.assertion_count])
-        print('%d failures, %d errors, ' % [runner.failures, runner.errors])
-        print('%d skips' % runner.skips)
+        print('%d tests, %d assertions, ' % [count, assertions])
+        print('%d failures, %d errors, ' % [failures, errors])
+        print('%d skips' % skips)
         puts
       end
 
       private
 
-      def print_test_with_time(suite, test)
-        total_time = Time.now - (runner.test_start_time || Time.now)
-        print(" #{suite}##{test} (%.2fs)" % total_time)
-      end
-
-      def print_info(e, name = true)
-        print "#{e.exception.class.to_s}: " if name
-        e.message.each_line { |line| puts pad(line) }
-
-        trace = filter_backtrace(e.backtrace)
-        trace.each { |line| puts pad(line) }
-      end
-
-      def pad(str)
-        ' ' * INFO_PADDING + str
+      def print_test_with_time(test)
+        print(" #{test.class}##{test.name} (%.2fs)" % test.time)
       end
     end
   end

data/lib/minitest/reporters/rubymine_reporter.rb

@@ -8,52 +8,32 @@ begin
   require 'teamcity/utils/runner_utils'
   require 'teamcity/utils/url_formatter'
 rescue LoadError
-  MiniTest::Unit.runner.output.puts("====================================================================================================\n")
-  MiniTest::Unit.runner.output.puts("RubyMine reporter works only if it test was launched using RubyMine IDE or TeamCity CI server !!!\n")
-  MiniTest::Unit.runner.output.puts("====================================================================================================\n")
-  MiniTest::Unit.runner.output.puts("Using default results reporter...\n")
+  puts("====================================================================================================\n")
+  puts("RubyMine reporter works only if it test was launched using RubyMine IDE or TeamCity CI server !!!\n")
+  puts("====================================================================================================\n")
+  puts("Using default results reporter...\n")
 
   require "minitest/reporters/default_reporter"
 
   # delegate to default reporter
-  module MiniTest
+  module Minitest
     module Reporters
       class RubyMineReporter < DefaultReporter
       end
     end
   end
 else
-  module MiniTest
+  module Minitest
     module Reporters
-      class RubyMineReporter
-        include Reporter
+      class RubyMineReporter < BaseReporter
         include ANSI::Code
 
         include ::Rake::TeamCity::RunnerCommon
         include ::Rake::TeamCity::RunnerUtils
         include ::Rake::TeamCity::Utils::UrlFormatter
 
-        def runner
-          MiniTest::Unit.runner
-        end
-
-        def output
-          runner.output
-        end
-
-        def verbose?
-          runner.verbose
-        end
-
-        def print(*args)
-          runner.output.print(*args)
-        end
-
-        def puts(*args)
-          runner.output.puts(*args)
-        end
-
-        def before_suites(suites, type)
+        def start
+          super
           puts 'Started'
           puts
 
@@ -62,27 +42,43 @@ else
           log_test_reporter_attached()
 
           # Report tests count:
-          test_count = runner.test_count
           if ::Rake::TeamCity.is_in_idea_mode
-            log(@message_factory.create_tests_count(test_count))
+            log(@message_factory.create_tests_count(total_count))
           elsif ::Rake::TeamCity.is_in_buildserver_mode
             log(@message_factory.create_progress_message("Starting.. (#{test_count} tests)"))
           end
 
         end
 
-        def after_suites(suites, type)
-          total_time = Time.now - runner.suites_start_time
+        def report
+          super
 
           puts('Finished in %.5fs' % total_time)
-          print('%d tests, %d assertions, ' % [runner.test_count, runner.assertion_count])
-          print(red { '%d failures, %d errors, ' } % [runner.failures, runner.errors])
-          print(yellow { '%d skips' } % runner.skips)
+          print('%d tests, %d assertions, ' % [count, assertions])
+          print(red { '%d failures, %d errors, ' } % [failures, errors])
+          print(yellow { '%d skips' } % skips)
           puts
         end
 
+        def record(test)
+          super
+          unless test.passed?
+            with_result(test) do |exception_msg, backtrace|
+              if test.skipped?
+                log(@message_factory.create_test_ignored(test, exception_msg, backtrace))
+              elsif test.error?
+                log(@message_factory.create_test_error(test, exception_msg, backtrace))
+              else
+                log(@message_factory.create_test_failed(test, exception_msg, backtrace))
+              end
+            end
+          end
+        end
+
+        alias_method :output, :io
+
         def before_suite(suite)
-          fqn = suite.name
+          fqn = suite.class
           log(@message_factory.create_suite_started(suite.name, location_from_ruby_qualified_name(fqn)))
         end
 
@@ -90,32 +86,15 @@ else
           log(@message_factory.create_suite_finished(suite.name))
         end
 
-        def before_test(suite, test)
-          fqn = "#{suite.name}.#{test.to_s}"
+        def before_test(test)
+          super
+          fqn = "#{test.class.name}.#{test.to_s}"
           log(@message_factory.create_test_started(test, minitest_test_location(fqn)))
         end
 
-        def after_test(suite, test)
-          duration_ms = get_current_time_in_ms() - get_time_in_ms(runner.test_start_time || Time.now)
-          log(@message_factory.create_test_finished(test, duration_ms.nil? ? 0 : duration_ms))
-        end
-
-        def skip(suite, test, test_runner)
-          with_result(test, test_runner) do |exception_msg, backtrace|
-            log(@message_factory.create_test_ignored(test, exception_msg, backtrace))
-          end
-        end
-
-        def failure(suite, test, test_runner)
-          with_result(test, test_runner) do |exception_msg, backtrace|
-            log(@message_factory.create_test_failed(test, exception_msg, backtrace))
-          end
-        end
-
-        def error(suite, test, test_runner)
-          with_result(test, test_runner) do |exception_msg, backtrace|
-            log(@message_factory.create_test_error(test, exception_msg, backtrace))
-          end
+        def after_test(test)
+          super
+          log(@message_factory.create_test_finished(test, test.time))
         end
 
         #########
@@ -133,20 +112,13 @@ else
           "ruby_minitest_qn://#{fqn}"
         end
 
-        def with_result(test, test_runner)
-          exception = test_runner.exception
+        def with_result(test)
+          exception = test.failure
           msg = exception.nil? ? "" : "#{exception.class.name}: #{exception.message}"
           backtrace = exception.nil? ? "" : filter_backtrace(exception.backtrace).join("\n")
 
           yield(msg, backtrace)
         end
-
-        def filter_backtrace(bt)
-          result = super
-          return result if result.nil? || result.empty?
-          # let's reject test/unit/assetions from the backtrace
-          result.reject { |line| line =~ /\/lib\/ruby\/[0-9.]+\/test\/unit\//}
-        end
       end
     end
   end