minitest-heat 0.0.6 → 0.0.10

data/lib/minitest/heat/location.rb

@@ -22,10 +22,10 @@ module Minitest
         end
       end
 
-      attr_reader :test_location, :backtrace
+      attr_reader :test_definition_location, :backtrace
 
-      def initialize(test_location, backtrace = [])
-        @test_location = TestDefinition.new(*test_location)
+      def initialize(test_definition_location, backtrace = [])
+        @test_definition_location = TestDefinition.new(*test_definition_location)
         @backtrace = Backtrace.new(backtrace)
       end
 
@@ -45,9 +45,9 @@ module Minitest
       #   test, and it raises an exception, then it's really a broken test rather than a proper
       #   faiure.
       #
-      # @return [Boolean] true if most relevant file is the same as the test location file
+      # @return [Boolean] true if final file in the backtrace is the same as the test location file
       def broken_test?
-        !test_file.nil? && test_file == most_relevant_file
+        !test_file.nil? && test_file == final_file
       end
 
       # Knows if the failure occurred in the actual project source code—as opposed to the test or
@@ -59,6 +59,15 @@ module Minitest
         !source_code_file.nil? && !broken_test?
       end
 
+
+
+      # The final location of the stacktrace regardless of whether it's from within the project
+      #
+      # @return [String] the relative path to the file from the project root
+      def final_file
+        Pathname(final_location.pathname)
+      end
+
       # The file most likely to be the source of the underlying problem. Often, the most recent
       #   backtrace files will be a gem or external library that's failing indirectly as a result
       #   of a problem with local source code (not always, but frequently). In that case, the best
@@ -69,78 +78,76 @@ module Minitest
         Pathname(most_relevant_location.pathname)
       end
 
-      # The line number of the `most_relevant_file` where the failure originated
+      # The final location from the stacktrace that is a test file
       #
-      # @return [Integer] line number
-      def most_relevant_failure_line
-        most_relevant_location.line_number
+      # @return [String, nil] the relative path to the file from the project root
+      def test_file
+        Pathname(final_test_location.pathname)
       end
 
-      # The final location of the stacktrace regardless of whether it's from within the project
+      # The final location from the stacktrace that is within the project directory
       #
-      # @return [String] the relative path to the file from the project root
-      def final_file
-        Pathname(final_location.pathname)
-      end
+      # @return [String, nil] the relative path to the file from the project root
+      def source_code_file
+        return nil if final_source_code_location.nil?
 
-      # The line number of the `final_file` where the failure originated
-      #
-      # @return [Integer] line number
-      def final_failure_line
-        final_location.line_number
+        Pathname(final_source_code_location.pathname)
       end
 
-      # The final location of the stacktrace regardless of whether it's from within the project
+      # The final location of the stacktrace from within the project (source code or test code)
       #
       # @return [String] the relative path to the file from the project root
       def project_file
-        broken_test? ? test_file : source_code_file
+        return nil if project_location.nil?
+
+        Pathname(project_location.pathname)
       end
 
-      # The line number of the `project_file` where the failure originated
+
+      # The line number of the `final_file` where the failure originated
       #
       # @return [Integer] line number
-      def project_failure_line
-        broken_test? ? test_failure_line || test_definition_line : source_code_failure_line
+      def final_failure_line
+        final_location.line_number
       end
 
-      # The final location from the stacktrace that is within the project directory
+      # The line number of the `most_relevant_file` where the failure originated
       #
-      # @return [String, nil] the relative path to the file from the project root
-      def source_code_file
-        return nil unless backtrace.source_code_entries.any?
-
-        backtrace.final_source_code_location.pathname
+      # @return [Integer] line number
+      def most_relevant_failure_line
+        most_relevant_location.line_number
       end
 
-      # The line number of the `source_code_file` where the failure originated
+      # The line number of the `test_file` where the test is defined
       #
       # @return [Integer] line number
-      def source_code_failure_line
-        return nil unless backtrace.source_code_entries.any?
-
-        backtrace.final_source_code_location.line_number
+      def test_definition_line
+        test_definition_location.line_number
       end
 
-      # The final location from the stacktrace that is within the project's test directory
+      # The line number from within the `test_file` test definition where the failure occurred
       #
-      # @return [String, nil] the relative path to the file from the project root
-      def test_file
-        Pathname(test_location.pathname)
+      # @return [Integer] line number
+      def test_failure_line
+        final_test_location.line_number
       end
 
-      # The line number of the `test_file` where the test is defined
+      # The line number of the `source_code_file` where the failure originated
       #
       # @return [Integer] line number
-      def test_definition_line
-        test_location.line_number
+      def source_code_failure_line
+        final_source_code_location&.line_number
       end
 
-      # The line number from within the `test_file` test definition where the failure occurred
+      # The line number of the `project_file` where the failure originated
       #
       # @return [Integer] line number
-      def test_failure_line
-        backtrace.final_test_location&.line_number || test_definition_line
+      def project_failure_line
+        if !broken_test? && !source_code_file.nil?
+          source_code_failure_line
+        else
+          test_failure_line
+        end
       end
 
       # The line number from within the `test_file` test definition where the failure occurred
@@ -148,7 +155,7 @@ module Minitest
       # @return [Location] the last location from the backtrace or the test location if a backtrace
       #   was not passed to the initializer
       def final_location
-        backtrace? ? backtrace.final_location : test_location
+        backtrace.parsed_entries.any? ? backtrace.final_location : test_definition_location
       end
 
       # The file most likely to be the source of the underlying problem. Often, the most recent
@@ -159,22 +166,33 @@ module Minitest
       # @return [Array] file and line number of the most likely source of the problem
       def most_relevant_location
         [
-          source_code_location,
-          test_location,
+          final_source_code_location,
+          final_test_location,
           final_location
         ].compact.first
       end
 
-      def project_location
-        source_code_location || test_location
+      # Returns the final test location based on the backtrace if present. Otherwise falls back to
+      #   the test location which represents the test definition.
+      #
+      # @return [Location] the final location from the test files
+      def final_test_location
+        backtrace.final_test_location || test_definition_location
       end
 
-      def source_code_location
+      # Returns the final source code location based on the backtrace
+      #
+      # @return [Location] the final location from the source code files
+      def final_source_code_location
         backtrace.final_source_code_location
       end
 
-      def backtrace?
-        backtrace.parsed_entries.any?
+      # Returns the final project location based on the backtrace if present. Otherwise falls back
+      #   to the test location which represents the test definition.
+      #
+      # @return [Location] the final location from the project files
+      def project_location
+        backtrace.final_project_location || test_definition_location
       end
     end
   end

data/lib/minitest/heat/map.rb

@@ -2,43 +2,40 @@
 
 module Minitest
   module Heat
+    # Structured approach to collecting the locations of issues for generating a heat map
     class Map
       MAXIMUM_FILES_TO_SHOW = 5
 
       attr_reader :hits
 
-      # So we can sort hot spots by liklihood of being the most important spot to check out before
-      #   trying to fix something. These are ranked based on the possibility they represent ripple
-      #   effects where fixing one problem could potentially fix multiple other failures.
-      #
-      #   For example, if there's an exception in the file, start there. Broken code can't run. If a
-      #   test is broken (i.e. raising an exception), that's a special sort of failure that would be
-      #   misleading. It doesn't represent a proper failure, but rather a test that doesn't work.
-      WEIGHTS = {
-        error: 3,    # exceptions from source code have the highest liklihood of a ripple effect
-        broken: 2,   # broken tests won't have ripple effects but can't help if they can't run
-        failure: 1,  # failures are kind of the whole point, and they could have ripple effects
-        skipped: 0,  # skips aren't failures, but they shouldn't go ignored
-        painful: 0,  # slow tests aren't failures, but they shouldn't be ignored
-        slow: 0
-      }.freeze
-
       def initialize
         @hits = {}
       end
 
+      # Records a hit to the list of files and issue types
+      # @param filename [String] the unique path and file name for recordings hits
+      # @param line_number [Integer] the line number where the issue was encountered
+      # @param type [Symbol] the type of issue that was encountered (i.e. :failure, :error, etc.)
+      #
+      # @return [void]
       def add(filename, line_number, type)
         @hits[filename] ||= Hit.new(filename)
 
-        @hits[filename].log(type, line_number)
+        @hits[filename].log(type.to_sym, line_number)
       end
 
+      # Returns a subset of affected files to keep the list from being overwhelming
+      #
+      # @return [Array] the list of files and the line numbers for each encountered issue type
       def file_hits
         hot_files.take(MAXIMUM_FILES_TO_SHOW)
       end
 
       private
 
+      # Sorts the files by hit "weight" so that the most problematic files are at the beginning
+      #
+      # @return [Array] the collection of files that encountred issues
       def hot_files
         hits.values.sort_by(&:weight).reverse
       end

data/lib/minitest/heat/output/backtrace.rb

@@ -5,7 +5,7 @@ module Minitest
     class Output
       # Builds the collection of tokens for a backtrace when an exception occurs
       class Backtrace
-        DEFAULT_LINE_COUNT = 5
+        DEFAULT_LINE_COUNT = 10
         DEFAULT_INDENTATION_SPACES = 2
 
         attr_accessor :location, :backtrace
@@ -23,13 +23,9 @@ module Minitest
           # Iterate over the selected lines from the backtrace
           backtrace_entries.each do |backtrace_entry|
             # Get the source code for the line from the backtrace
-            parts = [
-              indentation_token,
-              path_token(backtrace_entry),
-              file_and_line_number_token(backtrace_entry),
-              source_code_line_token(backtrace_entry.source_code)
-            ]
+            parts = backtrace_line_tokens(backtrace_entry)
 
+            # If it's the most recently modified file in the trace, add the token for that
             parts << file_freshness(backtrace_entry) if most_recently_modified?(backtrace_entry)
 
             @tokens << parts
@@ -52,11 +48,20 @@ module Minitest
         # ...it's smart about exceptions that were raised outside of the project?
         # ...it's smart about highlighting lines of code differently based on whether it's source code, test code, or external code?
         def backtrace_entries
-          project_entries
+          all_entries
         end
 
         private
 
+        def backtrace_line_tokens(backtrace_entry)
+          [
+            indentation_token,
+            path_token(backtrace_entry),
+            *file_and_line_number_tokens(backtrace_entry),
+            source_code_line_token(backtrace_entry.source_code)
+          ]
+        end
+
         def all_backtrace_entries_from_project?
           backtrace_entries.all? { |line| line.path.to_s.include?(project_root_dir) }
         end
@@ -83,25 +88,31 @@ module Minitest
         end
 
         def path_token(line)
+          style = line.to_s.include?(Dir.pwd) ? :default : :muted
           path = "#{line.path}/"
 
           # If all of the backtrace lines are from the project, no point in the added redundant
           #  noise of showing the project root directory over and over again
           path = path.delete_prefix(project_root_dir) if all_backtrace_entries_from_project?
 
-          [:muted, path]
+          [style, path]
         end
 
-        def file_and_line_number_token(backtrace_entry)
-          [:default, "#{backtrace_entry.file}:#{backtrace_entry.line_number}"]
+        def file_and_line_number_tokens(backtrace_entry)
+          style = backtrace_entry.to_s.include?(Dir.pwd) ? :bold : :muted
+          [
+            [style, backtrace_entry.file],
+            [:muted, ':'],
+            [style, backtrace_entry.line_number]
+          ]
         end
 
         def source_code_line_token(source_code)
-          [:muted, " `#{source_code.line.strip}`"]
+          [:muted, " #{Output::SYMBOLS[:arrow]} `#{source_code.line.strip}`"]
         end
 
         def file_freshness(_line)
-          [:bold, ' < Most Recently Modified']
+          [:default, " #{Output::SYMBOLS[:middot]} Most Recently Modified File"]
         end
 
         # The number of spaces each line of code should be indented. Currently defaults to 2 in
@@ -115,6 +126,10 @@ module Minitest
         def indentation
           DEFAULT_INDENTATION_SPACES
         end
+
+        def style_for(path)
+          path.to_s.include?(Dir.pwd) ? :default : :muted
+        end
       end
     end
   end

data/lib/minitest/heat/output/issue.rb

@@ -3,12 +3,8 @@
 module Minitest
   module Heat
     class Output
-      class Issue
-        SHARED_SYMBOLS = {
-          spacer: ' · ',
-          arrow: ' > '
-        }.freeze
-
+      # Formats issues to output based on the issue type
+      class Issue # rubocop:disable Metrics/ClassLength
         attr_accessor :issue
 
         def initialize(issue)
@@ -31,6 +27,7 @@ module Minitest
         def error_tokens
           [
             headline_tokens,
+            test_location_tokens,
             summary_tokens,
             *backtrace_tokens,
             newline_tokens
@@ -40,6 +37,7 @@ module Minitest
         def broken_tokens
           [
             headline_tokens,
+            test_location_tokens,
             summary_tokens,
             *backtrace_tokens,
             newline_tokens
@@ -49,9 +47,8 @@ module Minitest
         def failure_tokens
           [
             headline_tokens,
+            test_location_tokens,
             summary_tokens,
-            location_tokens,
-            *source_tokens,
             newline_tokens
           ]
         end
@@ -59,7 +56,7 @@ module Minitest
         def skipped_tokens
           [
             headline_tokens,
-            summary_tokens,
+            test_location_tokens,
             newline_tokens
           ]
         end
@@ -67,7 +64,7 @@ module Minitest
         def painful_tokens
           [
             headline_tokens,
-            slowness_tokens,
+            slowness_summary_tokens,
             newline_tokens
           ]
         end
@@ -75,17 +72,49 @@ module Minitest
         def slow_tokens
           [
             headline_tokens,
-            slowness_tokens,
+            slowness_summary_tokens,
             newline_tokens
           ]
         end
 
         def headline_tokens
-          [[issue.type, issue.label], [:muted, spacer], [:default, issue.test_name], [:muted, spacer], [:muted, issue.test_class]]
+          [[issue.type, label(issue)], spacer_token, [:default, test_name(issue)]]
         end
 
-        def summary_tokens
-          [[:italicized, issue.summary]]
+        def test_name(issue)
+          test_prefix = 'test_'
+          identifier = issue.test_identifier
+
+          if identifier.start_with?(test_prefix)
+            identifier.delete_prefix(test_prefix).gsub('_', ' ').capitalize
+          else
+            identifier
+          end
+        end
+
+        def label(issue)
+          if issue.error? && issue.in_test?
+            # When the exception came out of the test itself, that's a different kind of exception
+            # that really only indicates there's a problem with the code in the test. It's kind of
+            # between an error and a test.
+            'Broken Test'
+          elsif issue.error?
+            'Error'
+          elsif issue.skipped?
+            'Skipped'
+          elsif issue.painful?
+            'Passed but Very Slow'
+          elsif issue.slow?
+            'Passed but Slow'
+          elsif !issue.passed?
+            'Failure'
+          else
+            'Success'
+          end
+        end
+
+        def test_name_and_class_tokens
+          [[:default, issue.test_class], *test_location_tokens]
         end
 
         def backtrace_tokens
@@ -94,33 +123,74 @@ module Minitest
           backtrace.tokens
         end
 
+        def test_location_tokens
+          [[:default, test_file_short_location], [:muted, ':'], [:default, issue.test_definition_line], arrow_token, [:default, issue.test_failure_line], [:muted, test_line_source]]
+        end
+
         def location_tokens
-          [[:muted, issue.short_location]]
+          [[:default, most_relevant_short_location], [:muted, ':'], [:default, issue.location.most_relevant_failure_line], [:muted, most_relevant_line_source]]
         end
 
         def source_tokens
           filename    = issue.location.project_file
           line_number = issue.location.project_failure_line
 
-          source_code = ::Minitest::Heat::Output::SourceCode.new(filename, line_number)
+          source = Minitest::Heat::Source.new(filename, line_number: line_number)
+          [[:muted, " #{Output::SYMBOLS[:arrow]} `#{source.line.strip}`"]]
+        end
+
+        def summary_tokens
+          [[:italicized, issue.summary.delete_suffix('---------------').strip]]
+        end
 
-          source_code.tokens
+        def slowness_summary_tokens
+          [
+            [:bold, slowness(issue)],
+            spacer_token,
+            [:default, issue.location.test_file.to_s.delete_prefix(Dir.pwd)],
+            [:muted, ':'],
+            [:default, issue.location.test_definition_line]
+          ]
         end
 
-        def slowness_tokens
-          [[:bold, issue.slowness], [:muted, spacer], [:default, issue.short_location] ]
+        def slowness(issue)
+          "#{issue.execution_time.round(2)}s"
         end
 
         def newline_tokens
           []
         end
 
-        def spacer
-          SHARED_SYMBOLS[:spacer]
+        def most_relevant_short_location
+          issue.location.most_relevant_file.to_s.delete_prefix("#{Dir.pwd}/")
+        end
+
+        def test_file_short_location
+          issue.location.test_file.to_s.delete_prefix("#{Dir.pwd}/")
+        end
+
+        def most_relevant_line_source
+          filename    = issue.location.project_file
+          line_number = issue.location.project_failure_line
+
+          source = Minitest::Heat::Source.new(filename, line_number: line_number)
+          "\n  #{source.line.strip}"
+        end
+
+        def test_line_source
+          filename    = issue.location.test_file
+          line_number = issue.location.test_failure_line
+
+          source = Minitest::Heat::Source.new(filename, line_number: line_number)
+          "\n  #{source.line.strip}"
+        end
+
+        def spacer_token
+          Output::TOKENS[:spacer]
         end
 
-        def arrow
-          SHARED_SYMBOLS[:arrow]
+        def arrow_token
+          Output::TOKENS[:muted_arrow]
         end
       end
     end

data/lib/minitest/heat/output/map.rb

@@ -3,23 +3,25 @@
 module Minitest
   module Heat
     class Output
+      # Generates the tokens to output the resulting heat map
       class Map
-        # extend Forwardable
+        attr_accessor :results
 
-        attr_accessor :map
-
-        # def_delegators :@results, :errors, :brokens, :failures, :slows, :skips, :problems?, :slows?
-
-        def initialize(map)
-          @map = map
+        def initialize(results)
+          @results = results
           @tokens = []
         end
 
         def tokens
-          map.file_hits.each do |file|
+          map.file_hits.each do |hit|
+            file_tokens = pathname(hit)
+            line_number_tokens = line_numbers(hit)
+
+            next if line_number_tokens.empty?
+
             @tokens << [
-              *pathname(file),
-              *line_numbers(file)
+              *file_tokens,
+              *line_number_tokens
             ]
           end
 
@@ -28,8 +30,24 @@ module Minitest
 
         private
 
+        def map
+          results.heat_map
+        end
+
+        def relevant_issue_types
+          # These are always relevant.
+          issue_types = %i[error broken failure]
+
+          # These are only relevant if there aren't more serious isues.
+          issue_types << :skipped unless results.problems?
+          issue_types << :painful unless results.problems? || results.skips.any?
+          issue_types << :slow    unless results.problems? || results.skips.any?
+
+          issue_types
+        end
+
         def pathname(file)
-          directory = "#{file.pathname.dirname.to_s.delete_prefix(Dir.pwd)}/"
+          directory = "#{file.pathname.dirname.to_s.delete_prefix(Dir.pwd)}/".delete_prefix('/')
           filename = file.pathname.basename.to_s
 
           [
@@ -40,26 +58,31 @@ module Minitest
         end
 
         def hit_line_numbers(file, issue_type)
-          line_numbers_for_issue_type = file.issues.fetch(issue_type) { [] }
-
-          return nil if line_numbers_for_issue_type.empty?
-
           numbers = []
-          line_numbers_for_issue_type.sort.map do |line_number|
+          line_numbers_for_issue_type = file.issues.fetch(issue_type) { [] }
+          line_numbers_for_issue_type.map do |line_number|
             numbers << [issue_type, "#{line_number} "]
           end
+
           numbers
         end
 
         def line_numbers(file)
-          [
-            *hit_line_numbers(file, :error),
-            *hit_line_numbers(file, :broken),
-            *hit_line_numbers(file, :failure),
-            *hit_line_numbers(file, :skipped),
-            *hit_line_numbers(file, :painful),
-            *hit_line_numbers(file, :slow)
-          ].compact.sort_by { |number_token| number_token[1] }
+          line_number_tokens = []
+
+          # Merge the hits for all issue types into one list
+          relevant_issue_types.each do |issue_type|
+            line_number_tokens += hit_line_numbers(file, issue_type)
+          end
+
+          # Sort the collected group of line number hits so they're in order
+          line_number_tokens.compact.sort do |a, b|
+            # Ensure the line numbers are integers for sorting (otherwise '100' comes before '12')
+            first_line_number = Integer(a[1].strip)
+            second_line_number = Integer(b[1].strip)
+
+            first_line_number <=> second_line_number
+          end
         end
       end
     end