ace-test-runner 0.18.0

data/lib/ace/test_runner/atoms/result_parser.rb

@@ -0,0 +1,254 @@
+# frozen_string_literal: true
+
+module Ace
+  module TestRunner
+    module Atoms
+      # Parses test output into structured data
+      class ResultParser
+        # Patterns for parsing minitest output
+        PATTERNS = {
+          summary: /(\d+) (?:tests?|runs?), (\d+) assertions?, (\d+) failures?, (\d+) errors?, (\d+) skips?/,
+          failure: /^\s+\d+\) (Failure|Error):\n(.+?)(?=^\s+\d+\) |^Finished in|\z)/m,
+          # Pattern for inline verbose failures - match test name, FAIL marker, and content until next test or EOF
+          # Matches: "  test_name                 FAIL (0.02s)\n    error details\n    /path/file.rb:123..."
+          inline_failure: /^\s+(test_[\w_]+).*?FAIL.*?\([\d.]+s\)\n(.*?)(?=^\s+test_[\w_]+.*?(?:PASS|FAIL|ERROR|SKIP)|^Finished in|\z)/m,
+          # Pattern for inline errors - same structure as failures but with ERROR marker
+          inline_error: /^\s+(test_[\w_]+).*?ERROR.*?\([\d.]+s\)\n(.*?)(?=^\s+test_[\w_]+.*?(?:PASS|FAIL|ERROR|SKIP)|^Finished in|\z)/m,
+          location: /\[(.*?):(\d+)\]/,
+          duration: /Finished in ([\d.]+)s/,
+          deprecation: /DEPRECATION WARNING: (.+)/,
+          # Pattern to capture individual test times from verbose output
+          # Matches Minitest::Reporters DefaultReporter format:
+          #   "  test_name                     PASS (0.00s)"
+          test_time: /^\s+(test_[\w_]+).*?\s+(PASS|FAIL|ERROR|SKIP)\s+\(([\d.]+)s\)/,
+          # Pattern for standard Minitest verbose format:
+          # 1. "ClassName#test_name = 0.00 s = ."
+          # 2. "ClassName#test_name 0.00 = ."
+          test_time_standard: /^(\S+)#(test_[\w_]+)\s+(?:=\s+)?([\d.]+)\s*s?\s*=\s*([.FEWS])/
+        }.freeze
+
+        def parse_output(output)
+          # Clean ANSI color codes once for all parsing methods
+          clean_output = output.gsub(/\e\[[0-9;]*m/, "")
+
+          summary = parse_summary(clean_output)
+          failures = parse_failures(clean_output)
+          duration = parse_duration(clean_output)
+          deprecations = parse_deprecations(clean_output)
+          test_times = parse_test_times(clean_output)
+
+          {
+            raw_output: output,
+            summary: summary,
+            failures: failures,
+            duration: duration,
+            deprecations: deprecations,
+            test_times: test_times
+          }
+        end
+
+        def parse_summary(clean_output)
+          # clean_output already has ANSI codes removed
+          match = clean_output.match(PATTERNS[:summary])
+
+          return default_summary unless match
+
+          {
+            runs: match[1].to_i,
+            assertions: match[2].to_i,
+            failures: match[3].to_i,
+            errors: match[4].to_i,
+            skips: match[5].to_i,
+            passed: match[1].to_i - match[3].to_i - match[4].to_i - match[5].to_i
+          }
+        end
+
+        def parse_failures(clean_output)
+          # clean_output already has ANSI codes removed
+          failures = []
+
+          # First try to parse standard format failures
+          clean_output.scan(PATTERNS[:failure]) do |type, content|
+            failure = parse_single_failure(type, content)
+            failures << failure if failure
+          end
+
+          # If no failures found, try inline verbose format
+          # But ONLY if the output contains FAIL or ERROR to avoid expensive processing on success
+          if failures.empty? && (clean_output.include?(" FAIL ") || clean_output.include?(" ERROR "))
+            # Split by test headers and process each block
+            test_blocks = clean_output.split(/(?=^\s+test_[\w_]+)/).select { |s| s.match?(/^\s+test_/) }
+
+            test_blocks.each do |block|
+              # Check if this block contains a FAIL or ERROR
+              if block =~ /^\s+(test_[\w_]+).*?(ERROR|FAIL).*?\(([\d.]+)s\)\n(.*)/m
+                test_name = $1
+                type = ($2 == "ERROR") ? :error : :failure
+                content = $4
+
+                failure = parse_inline_failure(test_name, content, type)
+                failures << failure if failure
+              end
+            end
+          end
+
+          failures
+        end
+
+        def parse_duration(clean_output)
+          # clean_output already has ANSI codes removed
+          match = clean_output.match(PATTERNS[:duration])
+          match ? match[1].to_f : 0.0
+        end
+
+        def parse_deprecations(clean_output)
+          deprecations = []
+
+          clean_output.scan(PATTERNS[:deprecation]) do |message|
+            deprecations << message.first
+          end
+
+          deprecations.uniq
+        end
+
+        def parse_test_times(clean_output)
+          # clean_output already has ANSI codes removed
+          test_times = []
+
+          # Build location index first to avoid O(n²) complexity
+          location_index = {}
+          clean_output.scan(/(test_[\w_]+).*?\[(.*?):(\d+)\]/) do |name, file, line|
+            location_index[name] ||= "#{file}:#{line}"
+          end
+
+          # Try Minitest::Reporters DefaultReporter format first (most common)
+          # Format: "  test_name                     PASS (0.00s)"
+          clean_output.scan(PATTERNS[:test_time]) do |test_name, status, time|
+            test_times << {
+              name: test_name,
+              status: status,
+              duration: time.to_f,
+              location: location_index[test_name]
+            }
+          end
+
+          # If no matches, try standard Minitest verbose format
+          # Format: "ClassName#test_name = 0.00 s = ." or "ClassName#test_name 0.00 = ."
+          if test_times.empty?
+            clean_output.scan(PATTERNS[:test_time_standard]) do |class_name, test_name, time, status_char|
+              status = case status_char
+              when "." then "PASS"
+              when "F" then "FAIL"
+              when "E" then "ERROR"
+              when "S" then "SKIP"
+              else "UNKNOWN"
+              end
+              test_times << {
+                name: test_name,
+                class_name: class_name,
+                status: status,
+                duration: time.to_f,
+                location: location_index[test_name]
+              }
+            end
+          end
+
+          test_times.sort_by { |t| -t[:duration] }
+        end
+
+        private
+
+        def default_summary
+          {
+            runs: 0,
+            assertions: 0,
+            failures: 0,
+            errors: 0,
+            skips: 0,
+            passed: 0
+          }
+        end
+
+        def parse_single_failure(type, content)
+          lines = content.strip.lines
+          return nil if lines.empty?
+
+          # First line is test name
+          test_name = lines.first.strip
+
+          # Find location
+          location_match = content.match(PATTERNS[:location])
+          location = if location_match
+            {
+              file: location_match[1],
+              line: location_match[2].to_i
+            }
+          end
+
+          # Extract message (everything after test name and before location/backtrace)
+          message_lines = []
+          lines[1..-1].each do |line|
+            break if line.match?(PATTERNS[:location]) || line.strip.start_with?("/")
+            message_lines << line
+          end
+
+          {
+            type: type.downcase.to_sym,
+            test_name: test_name,
+            message: message_lines.join.strip,
+            location: location,
+            full_content: content.strip
+          }
+        end
+
+        def parse_inline_failure(test_name, content, type = :failure)
+          # Parse inline verbose format failures
+          # Example:
+          # test_handles_special_characters                                FAIL (0.00s)
+          #         Expected: "path\\to\\file"
+          #           Actual: nil
+          #         /Users/mc/Ps/ace/ace-core/test/atoms/env_parser_test.rb:50:in 'EnvParserTest#test_handles_special_characters'
+
+          lines = content.strip.lines
+
+          # Extract location from any line that looks like a file path (first occurrence)
+          location = nil
+          location_line_idx = nil
+          lines.each_with_index do |line, idx|
+            # Match absolute paths with .rb extension
+            if line =~ %r{^\s*(/[^:]+\.rb):(\d+)}
+              location = {
+                file: $1.strip,
+                line: $2.to_i
+              }
+              location_line_idx = idx
+              break
+            end
+          end
+
+          # Extract message (all lines before location, trimmed)
+          # Skip empty lines and indentation
+          message_lines = []
+          lines[0...location_line_idx].each do |line|
+            stripped = line.strip
+            next if stripped.empty?
+            message_lines << stripped
+          end
+
+          # If no message extracted, use first non-empty line
+          if message_lines.empty? && lines.any?
+            message_lines << lines.first.strip
+          end
+
+          {
+            type: type,
+            test_name: test_name,
+            message: message_lines.join("\n"),
+            location: location,
+            full_content: "#{test_name}\n#{content}".strip
+          }
+        end
+      end
+    end
+  end
+end

data/lib/ace/test_runner/atoms/test_detector.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module Ace
+  module TestRunner
+    module Atoms
+      # Detects and finds test files based on patterns
+      class TestDetector
+        DEFAULT_PATTERNS = [
+          "test/**/*_test.rb",
+          "spec/**/*_spec.rb",
+          "test/**/test_*.rb"
+        ].freeze
+
+        def initialize(patterns: nil, root_dir: ".")
+          @patterns = patterns || DEFAULT_PATTERNS
+          @root_dir = root_dir
+        end
+
+        def find_test_files
+          files = []
+
+          # Handle both hash (new format) and array (old format) patterns
+          patterns_to_search = if @patterns.is_a?(Hash)
+            @patterns.values
+          else
+            @patterns
+          end
+
+          patterns_to_search.each do |pattern|
+            full_pattern = File.join(@root_dir, pattern)
+            matched_files = Dir.glob(full_pattern).select { |f| File.file?(f) }
+            files.concat(matched_files)
+          end
+
+          # Filter out helper files that aren't actual test files
+          files = files.reject { |f| f.end_with?("/test_helper.rb", "/spec_helper.rb") }
+
+          files.uniq.sort
+        end
+
+        def filter_by_pattern(files, pattern)
+          return files unless pattern
+
+          regex = Regexp.new(pattern, Regexp::IGNORECASE)
+          files.select do |file|
+            file.match?(regex) || File.basename(file).match?(regex)
+          end
+        end
+
+        def test_file?(path)
+          return false unless File.exist?(path) && File.file?(path)
+
+          # Handle both hash (new format) and array (old format) patterns
+          patterns_to_check = if @patterns.is_a?(Hash)
+            @patterns.values
+          else
+            @patterns
+          end
+
+          patterns_to_check.any? do |pattern|
+            File.fnmatch?(pattern, path) ||
+              File.fnmatch?(pattern, path.sub(@root_dir + "/", ""))
+          end
+        end
+
+        def classify_file(file_path)
+          case file_path
+          when /test\/unit\/atoms\//
+            :atoms
+          when /test\/unit\/molecules\//
+            :molecules
+          when /test\/unit\/organisms\//
+            :organisms
+          when /test\/unit\/models\//
+            :models
+          when /test\/integration\//
+            :integration
+          when /test\/system\//
+            :system
+          when /test\/unit\//
+            :unit
+          when /spec\/unit\/atoms\//
+            :atoms
+          when /spec\/unit\/molecules\//
+            :molecules
+          when /spec\/unit\/organisms\//
+            :organisms
+          when /spec\/unit\/models\//
+            :models
+          when /spec\/integration\//
+            :integration
+          when /spec\/system\//
+            :system
+          when /spec\/unit\//
+            :unit
+          else
+            :other
+          end
+        end
+
+        def group_test_files(files)
+          grouped = Hash.new { |h, k| h[k] = [] }
+
+          files.each do |file|
+            group = classify_file(file)
+            grouped[group] << file
+          end
+
+          grouped
+        end
+      end
+    end
+  end
+end

data/lib/ace/test_runner/atoms/test_folder_detector.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Ace
+  module TestRunner
+    module Atoms
+      # Detects test folder location from test file paths and calculates report directory
+      module TestFolderDetector
+        module_function
+
+        # Given test file paths, find the test folder and calculate report directory
+        # Returns the parent directory of the test folder + "/test-reports"
+        #
+        # Example:
+        #   files = ["ace-taskflow/test/commands/tasks_command_test.rb"]
+        #   detect_report_dir(files) # => "ace-taskflow/test-reports"
+        def detect_report_dir(test_files)
+          return nil if test_files.nil? || test_files.empty?
+
+          # Get the first test file and find its test folder
+          first_file = test_files.first
+          test_folder = find_test_folder(first_file)
+
+          return nil unless test_folder
+
+          # Get parent directory and append test-reports
+          parent_dir = File.dirname(test_folder)
+          File.join(parent_dir, "test-reports")
+        end
+
+        # Find the test folder in a given file path
+        # Looks for "/test/" in the path and returns the path up to and including "test"
+        #
+        # Example:
+        #   find_test_folder("ace-taskflow/test/commands/tasks_command_test.rb")
+        #   # => "ace-taskflow/test"
+        def find_test_folder(file_path)
+          # Remove line number suffix if present (file:line format)
+          file_path = file_path.sub(/:\d+$/, "")
+
+          # Split path into parts
+          parts = file_path.split("/")
+
+          # Find index of "test" directory
+          test_index = parts.index("test")
+          return nil unless test_index
+
+          # Return path up to and including test directory
+          parts[0..test_index].join("/")
+        end
+      end
+    end
+  end
+end

data/lib/ace/test_runner/atoms/test_type_detector.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Ace
+  module TestRunner
+    module Atoms
+      # Detects whether tests need subprocess isolation based on their content and type
+      class TestTypeDetector
+        # Patterns that indicate a test needs subprocess isolation
+        SUBPROCESS_PATTERNS = [
+          /CommandExecutor/,           # Tests that execute shell commands
+          /Open3\./,                   # Direct subprocess usage
+          /Process\.(spawn|fork|kill)/, # Process manipulation
+          /Signal\./,                  # Signal handling
+          /system\(/,                  # System command execution
+          /`.*`/,                      # Backtick command execution
+          /\$\(.*\)/,                  # Command substitution
+          /run_in_subprocess/,         # Explicit subprocess test helpers
+          /run_in_clean_env/          # Environment isolation helpers
+        ].freeze
+
+        # Test directories that typically need isolation
+        ISOLATION_DIRS = %w[
+          integration
+          system
+          e2e
+          end_to_end
+        ].freeze
+
+        # Test directories that typically don't need isolation
+        UNIT_TEST_DIRS = %w[
+          atoms
+          molecules
+          organisms
+          models
+          unit
+        ].freeze
+
+        def needs_subprocess?(file_path)
+          # Check if explicitly marked as needing isolation
+          return true if isolation_directory?(file_path)
+
+          # Check if it's clearly a unit test that doesn't need isolation
+          return false if unit_test_directory?(file_path)
+
+          # Check file content for patterns that require subprocess
+          check_file_content(file_path)
+        end
+
+        def test_type(file_path)
+          if isolation_directory?(file_path)
+            :integration
+          elsif unit_test_directory?(file_path)
+            :unit
+          elsif check_file_content(file_path)
+            :subprocess_required
+          else
+            :unit
+          end
+        end
+
+        private
+
+        def isolation_directory?(file_path)
+          ISOLATION_DIRS.any? { |dir| file_path.include?("/#{dir}/") }
+        end
+
+        def unit_test_directory?(file_path)
+          UNIT_TEST_DIRS.any? { |dir| file_path.include?("/#{dir}/") }
+        end
+
+        def check_file_content(file_path)
+          return false unless File.exist?(file_path)
+
+          content = File.read(file_path)
+          SUBPROCESS_PATTERNS.any? { |pattern| content.match?(pattern) }
+        rescue
+          # If we can't read the file, assume it doesn't need isolation
+          false
+        end
+      end
+    end
+  end
+end

data/lib/ace/test_runner/atoms/timestamp_generator.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require "ace/b36ts"
+
+module Ace
+  module TestRunner
+    module Atoms
+      # Generates Base36 compact IDs for test reports
+      #
+      # Uses ace-b36ts to generate 6-character compact IDs (e.g., "i50jj3")
+      # for test report directories and files. Reports are temporary, so no
+      # backward compatibility with legacy timestamp format is needed.
+      #
+      # @example Generate a compact ID
+      #   generator = TimestampGenerator.new
+      #   generator.generate  # => "i50jj3"
+      #
+      # @example Generate ISO timestamp for human-readable output
+      #   generator = TimestampGenerator.new
+      #   generator.iso_timestamp  # => "2025-01-06T12:30:00"
+      #
+      class TimestampGenerator
+        ISO_FORMAT = "%Y-%m-%dT%H:%M:%S"
+
+        # Generate a Base36 compact ID for the given time
+        #
+        # @param time [Time] The time to encode (default: Time.now)
+        # @return [String] 6-character Base36 compact ID
+        def generate(time = Time.now)
+          Ace::B36ts.encode(time)
+        end
+
+        # Generate an ISO timestamp for human-readable output
+        #
+        # @param time [Time] The time to format (default: Time.now)
+        # @return [String] ISO formatted timestamp
+        def iso_timestamp(time = Time.now)
+          time.strftime(ISO_FORMAT)
+        end
+
+        # Generate a directory name (alias for generate)
+        #
+        # @param time [Time] The time to encode (default: Time.now)
+        # @return [String] 6-character Base36 compact ID
+        def directory_name(time = Time.now)
+          generate(time)
+        end
+
+        # Generate a filename timestamp with optional extension
+        #
+        # @param time [Time] The time to encode (default: Time.now)
+        # @param extension [String, nil] Optional file extension
+        # @return [String] Filename with optional extension
+        def filename_timestamp(time = Time.now, extension = nil)
+          base = generate(time)
+          extension ? "#{base}#{extension}" : base
+        end
+
+        # Parse a Base36 compact ID string to Time
+        #
+        # @param id_str [String] The Base36 ID string to parse
+        # @return [Time, nil] Parsed time or nil if invalid
+        def parse(id_str)
+          Ace::B36ts.decode(id_str)
+        rescue ArgumentError
+          nil
+        end
+
+        # Calculate elapsed time between two times
+        #
+        # @param start_time [Time] Start time
+        # @param end_time [Time] End time (default: Time.now)
+        # @return [String] Human-readable duration
+        def elapsed_time(start_time, end_time = Time.now)
+          duration = end_time - start_time
+          format_duration(duration)
+        end
+
+        # Detect the format of an ID string
+        #
+        # @param value [String] The ID string to analyze
+        # @return [Symbol, nil] :"2sec" for valid Base36 IDs, :timestamp for legacy format, or nil
+        def self.detect_format(value)
+          Ace::B36ts.detect_format(value)
+        end
+
+        private
+
+        def format_duration(seconds)
+          if seconds < 1
+            "#{(seconds * 1000).round(2)}ms"
+          elsif seconds < 60
+            "#{seconds.round(2)}s"
+          else
+            minutes = (seconds / 60).floor
+            remaining_seconds = (seconds % 60).round
+            "#{minutes}m #{remaining_seconds}s"
+          end
+        end
+      end
+    end
+  end
+end