minitest-heat 0.0.7 → 0.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7e33245f206aa23bcbad541459db13fb8f6f088df51777850bb1276369dc0b3b
-  data.tar.gz: f66fd4f6ba49d1f80be0f97e0d54fd5fa5a2f4fa2063a57f20d9f46520d17ed2
+  metadata.gz: 7a2dd8d434e13e9719addb1a2afa9f25c751ca6e5712c752244afb1823ac4740
+  data.tar.gz: 722f33b1145d79510f9007b54663198972c1ce4461a7a79c14a7bfdeb190721e
 SHA512:
-  metadata.gz: 24897c2218d77cae17eba80b0e28f24df8f051d13f3f2cddeb47ffabb4730a19b45601f34119749f7fa3d7828fbe617313821d6939cf41653e6559e91bf74526
-  data.tar.gz: 38b9e2b060ba864243e384ef260bfb9f771b607bc2786668d462abee84142d5505f3de63182e8238e94bc8ba01932f991125a4db1fcceb4252d764afcc7a62f8
+  metadata.gz: 955b848541141572e94aeff4b02586253f70db8e313af111e54b91c3e8a64c7c44c0f0f90c672f699f9296dc5f691ea04c7852eb948f6ab680173b8261512eee
+  data.tar.gz: 9c3085267bea53a6734a085c982fd8348442715036ccf2b636de9c997f3dc14662e25a709faab1b4425ffb46ceeb109f43672336fadf0bca7c4e0cbbccd0463c

data/.rubocop.yml

@@ -2,6 +2,7 @@ AllCops:
   NewCops: enable
   UseCache: true
   CacheRootDirectory: './'
+  TargetRubyVersion: 2.5.9
   Exclude:
     - 'bin/**/*'
     - 'test/files/source.rb' # An example test file for reading source code

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    minitest-heat (0.0.7)
+    minitest-heat (0.0.11)
       minitest
 
 GEM
@@ -10,7 +10,7 @@ GEM
     ast (2.4.2)
     awesome_print (1.9.2)
     coderay (1.1.3)
-    dead_end (1.1.7)
+    dead_end (3.0.2)
     docile (1.4.0)
     method_source (1.0.0)
     minitest (5.14.4)
@@ -24,7 +24,7 @@ GEM
     rake (12.3.3)
     regexp_parser (2.1.1)
     rexml (3.2.5)
-    rubocop (1.22.1)
+    rubocop (1.22.3)
       parallel (~> 1.10)
       parser (>= 3.0.0.0)
       rainbow (>= 2.2.2, < 4.0)
@@ -33,9 +33,9 @@ GEM
       rubocop-ast (>= 1.12.0, < 2.0)
       ruby-progressbar (~> 1.7)
       unicode-display_width (>= 1.4.0, < 3.0)
-    rubocop-ast (1.12.0)
+    rubocop-ast (1.13.0)
       parser (>= 3.0.1.1)
-    rubocop-minitest (0.15.1)
+    rubocop-minitest (0.15.2)
       rubocop (>= 0.90, < 2.0)
     rubocop-rake (0.6.0)
       rubocop (~> 1.0)
@@ -64,4 +64,4 @@ DEPENDENCIES
   simplecov
 
 BUNDLED WITH
-   2.1.4
+   2.2.30

data/README.md

@@ -21,7 +21,7 @@ Or install it yourself as:
 
     $ gem install minitest-heat
 
-And add this line to your `test/test_helper.rb` file:
+And depending on your usage, you may need to require Minitest Heat in your test suite:
 
 ```ruby
 require 'minitest/heat'

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

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'forwardable'
+
+module Minitest
+  module Heat
+    class Backtrace
+      # Represents a line from a backtrace to provide more convenient access to information about
+      #   the relevant file and line number for displaying in test results
+      module LineParser
+        # Parses a line from a backtrace in order to convert it to usable components
+        def self.read(raw_text)
+          raw_pathname, raw_line_number, raw_container = raw_text.split(':')
+          raw_container = raw_container.delete_prefix('in `').delete_suffix("'")
+
+          ::Minitest::Heat::Location.new(
+            pathname: raw_pathname,
+            line_number: raw_line_number,
+            container: raw_container
+          )
+        end
+      end
+    end
+  end
+end

data/lib/minitest/heat/backtrace.rb

@@ -1,69 +1,65 @@
 # frozen_string_literal: true
 
+require_relative 'backtrace/line_parser'
+
 module Minitest
   module Heat
     # Wrapper for separating backtrace into component parts
     class Backtrace
       attr_reader :raw_backtrace
 
+      # Creates a more flexible backtrace data structure by parsing the lines of the backtrace to
+      #   extract specific subsets of lines for investigating the offending files and line numbers
+      # @param raw_backtrace [Array] the array of lines from the backtrace
+      #
+      # @return [self]
       def initialize(raw_backtrace)
-        @raw_backtrace = raw_backtrace
+        @raw_backtrace = Array(raw_backtrace)
       end
 
+      # Determines if the raw backtrace has values in it
+      #
+      # @return [Boolean] true if there's no backtrace or it's empty
       def empty?
-        raw_backtrace.nil? || raw_backtrace.empty?
-      end
-
-      def final_location
-        parsed_entries.first
-      end
-
-      def final_project_location
-        project_entries.first
-      end
-
-      def freshest_project_location
-        recently_modified_entries.first
-      end
-
-      def final_source_code_location
-        source_code_entries.first
+        raw_backtrace.empty?
       end
 
-      def final_test_location
-        test_entries.first
-      end
-
-      def project_entries
-        @project_entries ||= parsed_entries.select { |entry| entry.path.to_s.include?(Dir.pwd) }
-      end
-
-      def recently_modified_entries
-        @recently_modified_entries ||= project_entries.sort_by(&:mtime).reverse
-      end
+      # All lines of the backtrace converted to Backtrace::LineParser's
+      #
+      # @return [Line] the full set of backtrace lines parsed as Backtrace::LineParser instances
+      def locations
+        return [] if raw_backtrace.nil?
 
-      def test_entries
-        @tests_entries ||= project_entries.select { |entry| test_file?(entry) }
+        @locations ||= raw_backtrace.map { |entry| Backtrace::LineParser.read(entry) }
       end
 
-      def source_code_entries
-        @source_code_entries ||= project_entries - test_entries
+      # All entries from the backtrace within the project and sorted with the most recently modified
+      #   files at the beginning
+      #
+      # @return [Line] the sorted backtrace lines from the project parsed as Backtrace::LineParser's
+      def recently_modified_locations
+        @recently_modified_locations ||= project_locations.sort_by(&:mtime).reverse
       end
 
-      def parsed_entries
-        return [] if raw_backtrace.nil?
-
-        @parsed_entries ||= raw_backtrace.map { |entry| Line.parse_backtrace(entry) }
+      # All entries from the backtrace that are files within the project
+      #
+      # @return [Line] the backtrace lines from within the project parsed as Backtrace::LineParser's
+      def project_locations
+        @project_locations ||= locations.select(&:project_file?)
       end
 
-      private
-
-      def parse(entry)
-        Line.parse_backtrace(entry)
+      # All entries from the backtrace within the project tests
+      #
+      # @return [Line] the backtrace lines from within the project tests parsed as Backtrace::LineParser's
+      def test_locations
+        @test_locations ||= project_locations.select(&:test_file?)
       end
 
-      def test_file?(entry)
-        entry.file.to_s.end_with?('_test.rb') || entry.file.to_s.start_with?('test_')
+      # All source code entries from the backtrace (i.e. excluding tests)
+      #
+      # @return [Line] the backtrace lines from within the source code parsed as Backtrace::LineParser's
+      def source_code_locations
+        @source_code_locations ||= project_locations.select(&:source_code_file?)
       end
     end
   end

data/lib/minitest/heat/hit.rb

@@ -5,8 +5,10 @@ require 'forwardable'
 module Minitest
   module Heat
     # Kind of like an issue, but instead of focusing on a failing test, it covers all issues for a
-    #   given file
+    #   given file to build a heat map of the affected files and line numbers
     class Hit
+      Trace = Struct.new(:type, :line_number, :locations)
+
       # 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.
@@ -15,46 +17,51 @@ module Minitest
       #   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 likelihood 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
+        error: 5,    # exceptions from source code have the highest likelihood of a ripple effect
+        broken: 4,   # broken tests won't have ripple effects but can't help if they can't run
+        failure: 3,  # failures are kind of the whole point, and they could have ripple effects
+        skipped: 2,  # skips aren't failures, but they shouldn't go ignored
+        painful: 1,  # slow tests aren't failures, but they shouldn't be ignored
         slow: 0
       }.freeze
 
-      attr_reader :pathname, :issues
+      attr_reader :pathname, :issues, :lines
 
+      # Creates an instance of a Hit for the given pathname. It must be the full pathname to
+      #   uniquely identify the file or we could run into collisions that muddy the water and
+      #   obscure which files had which errors on which line numbers
+      # @param pathname [Pathname,String] the full pathname to the file
+      #
+      # @return [self]
       def initialize(pathname)
         @pathname = Pathname(pathname)
         @issues = {}
+        @lines = {}
       end
 
-      def log(type, line_number)
-        @issues[type] ||= []
-        @issues[type] << line_number
-      end
-
-      def mtime
-        pathname.mtime
-      end
+      # Adds a record of a given issue type for the line number
+      # @param type [Symbol] one of Issue::TYPES
+      # @param line_number [Integer,String] the line number to record the issue on
+      # @param backtrace: nil [Array<Location>] the project locations from the backtrace
+      #
+      # @return [void]
+      def log(type, line_number, backtrace: [])
+        line_number = Integer(line_number)
+        issue_type = type.to_sym
 
-      def age_in_seconds
-        (Time.now - mtime).to_i
-      end
+        # Store issues by issue type with an array of line numbers
+        @issues[issue_type] ||= []
+        @issues[issue_type] << line_number
 
-      def critical_issues?
-        issues[:error].any? || issues[:broken].any? || issues[:failure].any?
-      end
-
-      def issue_count
-        count = 0
-        Issue::TYPES.each do |issue_type|
-          count += issues.fetch(issue_type) { [] }.size
-        end
-        count
+        # Store issues by line number with an array of Traces
+        @lines[line_number.to_s] ||= []
+        @lines[line_number.to_s] << Trace.new(issue_type, line_number, backtrace)
       end
 
+      # Calcuates an approximate weight to serve as a proxy for which files are most likely to be
+      #   the most problematic across the various issue types
+      #
+      # @return [Integer] the problem weight for the file
       def weight
         weight = 0
         issues.each_pair do |type, values|
@@ -63,6 +70,9 @@ module Minitest
         weight
       end
 
+      # The total issue count for the file across all issue types. Includes duplicates if they exist
+      #
+      # @return [Integer] the sum of the counts for all line numbers for all issue types
       def count
         count = 0
         issues.each_pair do |_type, values|
@@ -71,6 +81,9 @@ module Minitest
         count
       end
 
+      # The full set of unique line numbers across all issue types
+      #
+      # @return [Array<Integer>] the full set of unique offending line numbers for the hit
       def line_numbers
         line_numbers = []
         issues.each_pair do |_type, values|

data/lib/minitest/heat/issue.rb

@@ -17,36 +17,68 @@ module Minitest
         painful: 3.0
       }.freeze
 
-      attr_reader :result, :location, :failure
-
-      def_delegators :@result, :passed?, :error?, :skipped?
-      def_delegators :@location, :backtrace, :test_definition_line, :test_failure_line
+      attr_reader :assertions,
+                  :locations,
+                  :message,
+                  :test_class,
+                  :test_identifier,
+                  :execution_time,
+                  :passed,
+                  :error,
+                  :skipped
+
+      def_delegators :@locations, :backtrace, :test_definition_line, :test_failure_line
+
+      # Extracts the necessary data from result.
+      # @param result [Minitest::Result] the instance of Minitest::Result to examine
+      #
+      # @return [Issue] the instance of the issue to use for examining the result
+      def self.from_result(result)
+        # Not all results are failures, so we use the safe navigation operator
+        exception = result.failure&.exception
+
+        new(
+          assertions: result.assertions,
+          test_location: result.source_location,
+          test_class: result.klass,
+          test_identifier: result.name,
+          execution_time: result.time,
+          passed: result.passed?,
+          error: result.error?,
+          skipped: result.skipped?,
+          message: exception&.message,
+          backtrace: exception&.backtrace
+        )
+      end
+
+      # Creates an instance of Issue. In general, the `from_result` approach will be more convenient
+      #   for standard usage, but for lower-level purposes like testing, the initializer provides3
+      #   more fine-grained control
+      # @param assertions: 1 [Integer] the number of assertions in the result
+      # @param message: nil [String] exception if there is one
+      # @param backtrace: [] [Array<String>] the array of backtrace lines from an exception
+      # @param test_location: nil [Array<String, Integer>] the locations identifier for a test
+      # @param test_class: nil [String] the class name for the test result's containing class
+      # @param test_identifier: nil [String] the name of the test
+      # @param execution_time: nil [Float] the time it took to run the test
+      # @param passed: false [Boolean] true if the test explicitly passed, false otherwise
+      # @param error: false [Boolean] true if the test raised an exception
+      # @param skipped: false [Boolean] true if the test was skipped
+      #
+      # @return [type] [description]
+      def initialize(assertions: 1, test_location: ['Unrecognized Test File', 1], backtrace: [], execution_time: 0.0, message: nil, test_class: nil, test_identifier: nil, passed: false, error: false, skipped: false)
+        @message = message
 
-      def initialize(result)
-        @result = result
+        @assertions = Integer(assertions)
+        @locations = Locations.new(test_location, backtrace)
 
-        @failure = result.failures.any? ? result.failures.first : nil
-        @location = Location.new(result.source_location, @failure&.backtrace)
-      end
-
-      # Returns the primary location of the issue with the present working directory removed from
-      #   the string for conciseness
-      #
-      # @return [String] the pathname for the file relative to the present working directory
-      def short_location
-        location.to_s.delete_prefix("#{Dir.pwd}/")
-      end
+        @test_class = test_class
+        @test_identifier = test_identifier
+        @execution_time = Float(execution_time)
 
-      # Converts an issue to the key attributes for recording a 'hit'
-      #
-      # @return [Array] the filename, failure line, and issue type for categorizing a 'hit' to
-      #   support generating the heat map
-      def to_hit
-        [
-          location.project_file.to_s,
-          location.project_failure_line,
-          type
-        ]
+        @passed = passed
+        @error = error
+        @skipped = skipped
       end
 
       # Classifies different issue types so they can be categorized, organized, and prioritized.
@@ -58,7 +90,7 @@ module Minitest
       #   painfully slow and should get more attention.
       #
       # @return [Symbol] issue type for classifying issues and reporting
-      def type
+      def type # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
         if error? && in_test?
           :broken
         elsif error?
@@ -81,7 +113,7 @@ module Minitest
       #
       # @return [Boolean] true if the test did not pass or if it was slow
       def hit?
-        !passed? || slow?
+        !passed? || slow? || painful?
       end
 
       # Determines if a test should be considered slow by comparing it to the low end definition of
@@ -89,7 +121,7 @@ module Minitest
       #
       # @return [Boolean] true if the test took longer to run than `SLOW_THRESHOLDS[:slow]`
       def slow?
-        time >= SLOW_THRESHOLDS[:slow]
+        execution_time >= SLOW_THRESHOLDS[:slow] && execution_time < SLOW_THRESHOLDS[:painful]
       end
 
       # Determines if a test should be considered painfully slow by comparing it to the high end
@@ -97,77 +129,64 @@ module Minitest
       #
       # @return [Boolean] true if the test took longer to run than `SLOW_THRESHOLDS[:painful]`
       def painful?
-        time >= SLOW_THRESHOLDS[:painful]
+        execution_time >= SLOW_THRESHOLDS[:painful]
       end
 
       # Determines if the issue is an exception that was raised from directly within a test
       #   definition. In these cases, it's more likely to be a quick fix.
       #
-      # @return [Boolean] true if the final location of the stacktrace was a test file
+      # @return [Boolean] true if the final locations of the stacktrace was a test file
       def in_test?
-        location.broken_test?
+        locations.broken_test?
       end
 
       # Determines if the issue is an exception that was raised from directly within the project
       #   codebase.
       #
-      # @return [Boolean] true if the final location of the stacktrace was a file from the project
+      # @return [Boolean] true if the final locations of the stacktrace was a file from the project
       #   (as opposed to a dependency or Ruby library)
       def in_source?
-        location.proper_failure?
-      end
-
-      def test_class
-        result.klass
-      end
-
-      def test_identifier
-        result.name
-      end
-
-      def test_name
-        test_identifier.delete_prefix('test_').gsub('_', ' ').capitalize
+        locations.proper_failure?
       end
 
-      def exception
-        failure.exception
-      end
-
-      def time
-        result.time
+      # Was the result a pass? i.e. Skips aren't passes or failures. Slows are still passes. So this
+      #   is purely a measure of whether the test explicitly passed all assertions
+      #
+      # @return [Boolean] false for errors, failures, or skips, true for passes (including slows)
+      def passed?
+        passed
       end
 
-      def slowness
-        "#{time.round(2)}s"
+      # Was there an exception that triggered a failure?
+      #
+      # @return [Boolean] true if there's an exception
+      def error?
+        error
       end
 
-      def label
-        if error? && 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 error? || !passed?
-          failure.result_label
-        elsif painful?
-          'Passed but Very Slow'
-        elsif slow?
-          'Passed but Slow'
-        end
+      # Was the test skipped?
+      #
+      # @return [Boolean] true if the test was explicitly skipped, false otherwise
+      def skipped?
+        skipped
       end
 
+      # The more nuanced detail of the failure. If it's an error, digs into the exception. Otherwise
+      #   uses the message from the result
+      #
+      # @return [String] a more detailed explanation of the issue
       def summary
-        error? ? exception_parts[0] : exception.message
+        # When there's an exception, use the first line from the exception message. Otherwise,  the
+        #   message represents explanation for a test failure, and should be used in full
+        error? ? first_line_of_exception_message : message
       end
 
-      def freshest_file
-        backtrace.recently_modified.first
-      end
-
-      private
-
-      def exception_parts
-        exception.message.split("\n")
+      # Returns the first line of an exception message when the issue is from a proper exception
+      #   failure since exception messages can be long and cumbersome.
+      #
+      # @return [String] the first line of the exception message
+      def first_line_of_exception_message
+        message.split("\n")[0]
       end
     end
   end