minitest-bender 0.0.3 → 1.0.0

data/lib/minitest-bender/states/failing.rb

@@ -1,18 +1,21 @@
+# coding: utf-8
+# frozen_string_literal: true
+
 module MinitestBender
   module States
     class Failing < Base
-      COLOR = :red_500
-      LABEL = 'FAILED'.freeze
-      GROUP_LABEL = 'FAILURES'.freeze
+      COLOR = :fail
+      LABEL = 'FAILED'
+      GROUP_LABEL = 'FAILURES'
+      ICON = '✖'
 
       def formatted_message(result)
-        @formatted_message ||= colored(location(result))
+        colored(location(result))
       end
 
-      def summary_message(results)
-        filtered_results = only_with_this_state(results)
-        return '' if filtered_results.empty?
-        colored("#{filtered_results.size} failed")
+      def summary_message
+        return '' if results.empty?
+        colored("#{results.size} failed")
       end
     end
   end

data/lib/minitest-bender/states/passing.rb

@@ -1,22 +1,33 @@
+# coding: utf-8
+# frozen_string_literal: true
+
 module MinitestBender
   module States
     class Passing < Base
-      COLOR = :green_500
-      LABEL = 'PASSED'.freeze
-      GROUP_LABEL = 'PASSING'.freeze
+      COLOR = :pass
+      LABEL = 'PASSED'
+      GROUP_LABEL = 'PASSING'
+      ICON = '✔'
 
       def formatted_message(_result)
         ''
       end
 
-      def print_details(_io, _results)
+      def print_details(_io)
         :no_details
       end
 
-      def summary_message(results)
-        filtered_results = only_with_this_state(results)
-        return '' if filtered_results.empty?
-        colored("#{filtered_results.size} passed")
+      def detail_lines(_result)
+        []
+      end
+
+      def detail_lines_without_header(_result)
+        []
+      end
+
+      def summary_message
+        return '' if results.empty?
+        colored("#{results.size} passed")
       end
     end
   end

data/lib/minitest-bender/states/raising.rb

@@ -1,46 +1,68 @@
+# coding: utf-8
+# frozen_string_literal: true
+
 module MinitestBender
   module States
     class Raising < Base
-      COLOR = :amber_300
-      LABEL = 'RAISED'.freeze
-      GROUP_LABEL = 'ERRORS'.freeze
+      COLOR = :error
+      LABEL = 'RAISED'
+      GROUP_LABEL = 'ERRORS'
+      ICON = '💥'
 
       def formatted_message(result)
-        @formatted_message ||= colored(detailed_error_message(result))
+        colored(error_message(result))
       end
 
-      def summary_message(results)
-        filtered_results = only_with_this_state(results)
-        return '' if filtered_results.empty?
-        colored("#{filtered_results.size} raised an error")
+      def summary_message
+        return '' if results.empty?
+        colored("#{results.size} raised an error")
       end
 
       def test_location(result)
-        backtrace_line = backtrace(result).select { |line| line =~ /\/test\/|\/spec\// }.last
-        Utils.relative_path(backtrace_line).split(':').first
+        Utils.relative_path(result.file_path)
       end
 
       private
 
-      def do_print_details(io, result, padding)
-        io.puts "#{padding}#{colored(error_message(result))}"
+      def inner_detail_lines(result, padding)
+        lines = []
+        message = colored(error_message(result))
+        lines << "#{padding}#{message.gsub("\n", "\n#{padding}")}"
         backtrace(result).each do |line|
-          io.puts "#{padding}#{Colorin.brown_400(line)}"
+          adjusted_line = Utils.with_home_shorthand(line)
+          lines << "#{padding}#{Colorizer.colorize(adjusted_line, :backtrace)}"
         end
+        lines
       end
 
       def error_message(result)
-        exception = result.failures[0].exception
-        "#{exception.class}: #{exception.message}"
+        error = result.failures[0].error
+        "#{error.class}: #{error.message}"
       end
 
-      def detailed_error_message(result)
-        details = Utils.relative_path(backtrace(result)[0])
-        "#{error_message(result)}\n    (#{details})"
+      def backtrace(result)
+        case backtrace_view
+        when :user
+          user_backtrace(result)
+        when :full
+          full_backtrace(result)
+        else
+          raise "unknown backtrace view: #{backtrace_view}"
+        end
       end
 
-      def backtrace(result)
-        result.failures[0].backtrace
+      def backtrace_view
+        Minitest::Bender.configuration.backtrace_view
+      end
+
+      def user_backtrace(result)
+        full_backtrace(result).take_while do |line|
+          line !~ %r{minitest/test\.rb}
+        end
+      end
+
+      def full_backtrace(result)
+        result.failures[0].backtrace || []
       end
     end
   end

data/lib/minitest-bender/states/skipped.rb

@@ -1,20 +1,23 @@
+# coding: utf-8
+# frozen_string_literal: true
+
 module MinitestBender
   module States
     class Skipped < Base
-      COLOR = :cyan_300
-      LABEL = 'SKIPPED'.freeze
-      GROUP_LABEL = 'SKIPS'.freeze
+      COLOR = :skip
+      LABEL = 'SKIPPED'
+      GROUP_LABEL = 'SKIPS'
+      ICON = '○'
 
       def formatted_message(result)
-        @formatted_message ||= colored(result.failures[0].message)
+        colored(result.failures[0].message)
       end
 
-      def summary_message(results)
-        filtered_results = only_with_this_state(results)
-        return '' if filtered_results.empty?
-        skipped_count = filtered_results.size
+      def summary_message
+        return '' if results.empty?
+        skipped_count = results.size
         auxiliary_verb = skipped_count == 1 ? 'was' : 'were'
-        colored("#{filtered_results.size} #{auxiliary_verb} skipped")
+        colored("#{skipped_count} #{auxiliary_verb} skipped")
       end
     end
   end

data/lib/minitest-bender/utils.rb

@@ -1,7 +1,33 @@
+# frozen_string_literal: true
+
 module MinitestBender
   module Utils
     def self.relative_path(full_path)
       full_path.gsub("#{Dir.pwd}/", '')
     end
+
+    def self.with_home_shorthand(full_path)
+      if ENV['HOME'].to_s.start_with?('/home/')
+        full_path.sub(ENV['HOME'], '~')
+      else
+        full_path
+      end
+    end
+
+    def self.english_join(strings)
+      strings.reject(&:empty?).join(', ').gsub(/(.*), /, '\1 and ')
+    end
+
+    def self.with_symbolized_keys(hash)
+      hash.each_with_object({}) do |(k, v), h|
+        h[k.to_sym] = v
+      end
+    end
+
+    def self.without_nil_values(hash)
+      hash.each_with_object({}) do |(k, v), h|
+        h[k] = v unless v.nil?
+      end
+    end
   end
 end

data/lib/minitest-bender/version.rb

@@ -1,3 +1,3 @@
 module MinitestBender
-  VERSION = '0.0.3'.freeze
+  VERSION = '1.0.0'.freeze
 end

data/lib/minitest/bender.rb

@@ -3,78 +3,130 @@ require 'minitest_bender'
 
 module Minitest
   class Bender < AbstractReporter
-    attr_reader :io, :options, :previous_context, :results, :started_at
+    Colorizer = MinitestBender::Colorizer
+
+    attr_accessor :io, :options
+    attr_reader :previous_context, :results, :results_by_context, :started_at
+
+    class << self
+      def enable!(client_config = {})
+        @is_enabled = true
+        configuration.add_client_config(client_config)
+        Colorizer.custom_colors = configuration.custom_colors
+      end
+
+      def enabled?
+        @is_enabled ||= false
+      end
+
+      def configuration
+        @configuration ||= MinitestBender::Configuration.new
+      end
+    end
 
     def initialize(io, options = {})
       @io = io
       @options = options
       @previous_context = nil
       @results = []
-      @slowness_podium_is_relevant = false
+      @results_by_context = {}
+      @time_ranking_is_relevant = false
     end
 
     def start
       @started_at = Time.now
       io.puts
-      io.puts Colorin.white("Minitest started at #{started_at}")
-      io.puts Colorin.white("Options: #{options_args}")
+      io.puts Colorizer.colorize("Minitest started at #{started_at}", :normal)
+      io.puts Colorizer.colorize("Options: #{options_args}", :normal)
       io.puts
+      io.flush
     end
 
     def record(minitest_result)
+      flush_stdio
+
       result = MinitestBender.result_factory.create(minitest_result)
       results << result
 
       current_context = result.context
 
       if current_context != previous_context
-        io.puts
-        io.puts(result.header)
+        recorder.print_context_with_results(previous_context, results_by_context[previous_context]) unless previous_context.nil?
+        recorder.print_context(current_context)
         @previous_context = current_context
       end
 
-      @slowness_podium_is_relevant = true if result.time > 0.01
+      (results_by_context[current_context] ||= []) << result
+
+      @time_ranking_is_relevant = true if result.time > 0.01
+
+      if run_count == total_tests_count
+        recorder.print_context_with_results(current_context, results_by_context[current_context])
+      end
 
-      io.puts result.line_to_report
+      recorder.print_result(result)
+
+      io.flush
     end
 
     def passed?
-      passed_count + skipped_count == test_count
+      passed_count + skipped_count == run_count
     end
 
     def report
-      io.puts
-      print_divider(:white)
-
-      print_details
-
-      if @slowness_podium_is_relevant && passed?
-        print_slowness_podium
-        io.puts
+      if results.empty?
+        print_no_tests_status
+        return
       end
 
-      print_statistics
       io.puts
+      io.puts
+      print_divider(:normal)
 
-      print_suite_status
+      print_sections
     end
 
     private
 
-    def options_args
-      options.fetch(:args, '(none)')
+    def configuration
+      self.class.configuration
     end
 
-    def passed_without_skips?
-      passed_count == test_count
+    def flush_stdio
+      # as we might already have some output from the test itself,
+      # make sure we see *all* of it before we report anything
+      STDOUT.flush
+      STDERR.flush
     end
 
-    def run_all_tests?
-      !options_args.include?('--name')
+    def options_args
+      options.fetch(:args, '(none)')
     end
 
-    def test_count
-      results.size
+    def recorder
+      @recorder ||= begin
+        recorder_sym = configuration.recorder
+        case recorder_sym
+        when :progress
+          MinitestBender::Recorders::Progress.new(io, total_tests_count)
+        when :progress_groups
+          MinitestBender::Recorders::ProgressGroups.new(io, total_tests_count)
+        when :progress_issues
+          MinitestBender::Recorders::ProgressIssues.new(io, total_tests_count)
+        when :progress_groups_and_issues
+          MinitestBender::Recorders::ProgressGroupsAndIssues.new(io, total_tests_count)
+        when :progress_verbose
+          MinitestBender::Recorders::ProgressVerbose.new(io, total_tests_count)
+        when :icons
+          MinitestBender::Recorders::Icons.new(io)
+        when :grouped_icons
+          MinitestBender::Recorders::GroupedIcons.new(io)
+        when :none
+          MinitestBender::Recorders::None.new
+        else
+          raise "unknown recorder: #{recorder_sym}"
+        end
+      end
     end
 
     def passed_count
@@ -85,74 +137,111 @@ module Minitest
       @skipped_count ||= results.count(&:skipped?)
     end
 
-    def assertion_count
-      @assertion_count ||= results.reduce(0) { |acum, result| acum + result.assertions }
-    end
-
-    def print_divider(color)
-      io.puts(Colorin.public_send(color, '  _______________________').bold)
-      io.puts
+    def run_count
+      results.size
     end
 
-    def print_details
-      states = MinitestBender.states.values
-      symbols = states.map { |state| state.print_details(io, results) }
-      io.puts unless symbols.all? { |symbol| symbol == :no_details }
-    end
+    # Minitest should share this with reporters...
+    def total_tests_count
+      @total_tests_count ||= begin
+        filter = options[:filter] || '/./'
+        filter = Regexp.new($1) if filter.is_a?(String) && filter =~ %r%/(.*)/%
 
-    def print_statistics
-      total_tests = "#{test_count} tests"
-      total_tests = total_tests.chop if test_count == 1
-      formatted_total_tests = Colorin.blue_a700(total_tests)
+        exclude = options[:exclude]
+        exclude = Regexp.new($1) if exclude.is_a?(String) && exclude =~ %r%/(.*)/%
 
-      total_assertions = "#{assertion_count} assertions"
-      total_assertions = total_assertions.chop if assertion_count == 1
-      formatted_total_assertions = Colorin.purple_400(total_assertions)
+        Minitest::Runnable.runnables.map do |runnable|
+          runnable.runnable_methods.count do |m|
+            (filter === m || filter === "#{runnable}##{m}") &&
+            !(exclude === m || exclude === "#{runnable}##{m}")
+          end
+        end.inject(:+)
+      end
+    end
 
-      auxiliary_verb = test_count == 1 ? 'was' : 'were'
+    def print_no_tests_status
+      message = no_tests_message
+      padded_message = "  #{message}"
+      io.puts(Colorizer.colorize(padded_message, :tests))
+      print_divider(:tests, message.length)
+    end
 
-      total_time = (Time.now - started_at).round(3)
-      formatted_total_time = Colorin.grey_700("#{total_time} seconds")
+    def no_tests_message
+      'NO TESTS WERE RUN!  (-_-)zzz'.freeze
+    end
 
-      tests_rate = Colorin.grey_700("#{(test_count / total_time).round(4)} tests/s")
-      assertions_rate = Colorin.grey_700("#{(assertion_count / total_time).round(4)} assertions/s")
+    def print_divider(color, line_length = 23)
+      io.puts(Colorizer.colorize("  #{'_' * line_length}", color, :bold))
+      io.puts
+    end
 
-      io.puts "  #{formatted_total_tests} with #{formatted_total_assertions} #{auxiliary_verb} run in #{formatted_total_time} (#{tests_rate}, #{assertions_rate})"
+    def print_sections
+      sections.each(&:print)
+    end
+
+    def sections
+      section_names.map do |section_name|
+        case section_name
+        when :overview
+          MinitestBender::Sections::SortedOverview.new(io, results_by_context)
+        when :time_ranking
+          MinitestBender::Sections::TimeRanking.new(io, time_ranking_size, results)
+        when :issues
+          MinitestBender::Sections::Issues.new(io)
+        when :activity
+          MinitestBender::Sections::Activity.new(io, started_at, results)
+        when :suite_status
+          MinitestBender::Sections::SuiteStatus.new(io, options, results, total_tests_count)
+        else
+          raise "unknown section: #{section_name}"
+        end
+      end
     end
 
-    def print_suite_status
-      all_passed_color = MinitestBender.passing_color
-      final_divider_color = all_passed_color
+    def section_names
+      configuration.sections
+    end
 
-      if passed_without_skips? && run_all_tests?
-        message = Colorin.public_send(all_passed_color, '  ALL TESTS PASS!  (^_^)/')
+    def time_ranking_size
+      if @time_ranking_is_relevant
+        configuration.time_ranking_size
       else
-        messages = MinitestBender.states.values.map do |state|
-          summary_message = state.summary_message(results)
-          final_divider_color = state.color unless summary_message.empty?
-          summary_message
-        end
-
-        message = "  #{messages.reject(&:empty?).join(', ').gsub(/(.*), /, '\1 and ')}"
+        0
       end
-      io.puts(message)
-
-      print_divider(final_divider_color)
     end
+  end
 
-    def print_slowness_podium
-      results.sort_by! { |r| -r.time }
+  ##
+  # Compatibility with
+  # [minitest-reporters](https://github.com/kern/minitest-reporters)
+  #
+  # Given:
+  #
+  # ```
+  # require 'minitest/reporters'
+  # Minitest::Reporters.use!
+  # ```
+  #
+  # Bender can be selected with:
+  #
+  # ```
+  # MINITEST_REPORTER=BenderReporter rake test
+  # ```
+
+  module Reporters
+    class BenderReporter < Minitest::Bender
+      def initialize(options = {})
+        super(options.fetch(:io, $stdout), options)
+        Minitest::Bender.enable!
+      end
 
-      io.puts(formatted_slowness_podium_label)
-      io.puts
-      results.take(3).each_with_index do |result, i|
-        number = "#{i + 1})".ljust(4)
-        io.puts "    #{number}#{result.line_for_slowness_podium}"
+      def add_defaults(defaults)
+        @options = defaults.merge(options)
       end
-    end
 
-    def formatted_slowness_podium_label
-      "  #{Colorin.grey_700('SLOWNESS PODIUM').bold.underline}"
+      def before_test(_test_cls); end
+
+      def after_test(_test_cls); end
     end
   end
 end