ace-test-runner 0.18.0

data/Rakefile

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require "bundler/gem_tasks"
+require "minitest/test_task"
+
+desc "Run tests using ace-test"
+task :test do
+  sh "ace-test"
+end
+
+desc "Run tests directly (CI mode)"
+Minitest::TestTask.create(:ci)
+
+task default: :test

data/exe/ace-test

@@ -0,0 +1,26 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Prevent Minitest from autorunning when ace-test exits
+ENV["MT_NO_AUTORUN"] = "1"
+
+require_relative "../lib/ace/test_runner"
+
+# Start ace-support-cli with exception-based exit code handling (per ADR-023)
+# IMPORTANT: Use exit! (not exit) to skip Ruby's at_exit handlers.
+# This prevents Minitest from auto-running again via its at_exit hook.
+# When ace-test uses in-process (direct) execution, test files are loaded
+# into the current process. Minitest registers an at_exit handler that would
+# re-run all tests on normal exit. Using exit! bypasses this.
+# See guide://testable-code-patterns for details on this pattern.
+begin
+  exit_code = Ace::Support::Cli::Runner.new(Ace::TestRunner::CLI::Commands::Test).call(args: ARGV)
+  $stdout.flush
+  $stderr.flush
+  exit!(exit_code.respond_to?(:to_i) ? exit_code.to_i : 0)
+rescue Ace::Support::Cli::Error => e
+  warn e.message
+  $stdout.flush
+  $stderr.flush
+  exit!(e.exit_code)
+end

data/exe/ace-test-suite

@@ -0,0 +1,149 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "optparse"
+require "ace/core"
+require "ace/test_runner"
+require "ace/test_runner/suite"
+
+options = {
+  config: ".ace/test/suite.yml",
+  parallel: nil,
+  group: nil,
+  verbose: false,
+  progress: false
+}
+
+parser = OptionParser.new do |opts|
+  # Custom banner matching ace-support-cli ALL-CAPS style
+  opts.banner = <<~BANNER.chomp
+    NAME
+      ace-test-suite - Run all tests across the monorepo
+
+    USAGE
+      ace-test-suite [OPTIONS]
+
+    OPTIONS
+  BANNER
+
+  opts.on("-c", "--config FILE", "Configuration file (default: .ace/test/suite.yml)") do |config|
+    options[:config] = config
+  end
+
+  opts.on("-p", "--parallel N", Integer, "Maximum parallel processes") do |n|
+    options[:parallel] = n
+  end
+
+  opts.on("-g", "--group GROUP", "Run only packages in specified group") do |group|
+    options[:group] = group
+  end
+
+  opts.on("-v", "--verbose", "Show verbose output") do
+    options[:verbose] = true
+  end
+
+  opts.on("--progress", "Enable live animated display with progress bars") do
+    options[:progress] = true
+  end
+
+  opts.on("--no-color", "Disable colored output") do
+    options[:no_color] = true
+  end
+
+  opts.on("-h", "--help", "Show this help") do
+    puts opts
+    puts
+    puts "EXAMPLES"
+    puts "  $ ace-test-suite                    Run all (simple line-by-line output)"
+    puts "  $ ace-test-suite --progress         Show live animated progress bars"
+    puts "  $ ace-test-suite --parallel 16      Run with 16 parallel processes"
+    puts "  $ ace-test-suite --group foundation Run only foundation group"
+    puts "  $ ace-test-suite --verbose          Show detailed test output"
+    exit 0
+  end
+
+  opts.on("--version", "Show version") do
+    puts "ace-test-suite #{Ace::TestRunner::VERSION}"
+    exit 0
+  end
+end
+
+begin
+  parser.parse!(ARGV)
+rescue OptionParser::InvalidArgument => e
+  puts "Error: #{e.message}"
+  puts
+  puts parser
+  exit 1
+end
+
+# Load the config using namespace method
+config = Ace::Core.get("test", file: "suite")
+
+unless config.is_a?(Hash) && config["test_suite"].is_a?(Hash)
+  puts "Error: Configuration file not found: .ace/test/suite.yml"
+  puts
+  puts "Create a test suite configuration at .ace/test/suite.yml in your project root"
+  puts
+  puts "Example configuration:"
+  puts <<~YAML
+    test_suite:
+      max_parallel: 10
+      packages:
+        - name: ace-support-core
+          path: ./ace-support-core
+          group: foundation
+          priority: 1
+        - name: ace-test-runner
+          path: ./ace-test-runner
+          group: foundation
+          priority: 1
+      test_options:
+        format: compact
+        save_reports: true
+  YAML
+  exit 1
+end
+
+# Override config with command line options if provided
+if options[:parallel]
+  config["test_suite"]["max_parallel"] = options[:parallel]
+end
+
+if options[:group]
+  config["test_suite"]["packages"].select! { |p| p["group"] == options[:group] }
+  if config["test_suite"]["packages"].empty?
+    puts "Error: No packages found in group '#{options[:group]}'"
+    exit 1
+  end
+end
+
+if options[:no_color]
+  config["test_suite"]["display"] ||= {}
+  config["test_suite"]["display"]["color"] = false
+end
+
+if options[:verbose]
+  config["test_suite"]["test_options"] ||= {}
+  config["test_suite"]["test_options"]["verbose"] = true
+end
+
+if options[:progress]
+  config["test_suite"]["progress"] = true
+end
+
+# Run the test suite with the config
+begin
+  exit_code = Ace::TestRunner::Suite.run(config)
+  exit exit_code
+rescue Ace::TestRunner::Suite::Error => e
+  puts "Error: #{e.message}"
+  exit 1
+rescue Interrupt
+  puts "\n\nTest suite execution interrupted"
+  exit 130
+rescue => e
+  puts "Unexpected error: #{e.message}"
+  puts e.backtrace if options[:verbose]
+  exit 1
+end

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

@@ -0,0 +1,165 @@
+# frozen_string_literal: true
+
+require_relative "line_number_resolver"
+
+module Ace
+  module TestRunner
+    module Atoms
+      # Builds test execution commands
+      class CommandBuilder
+        def initialize(ruby_command: "ruby", bundler: true)
+          @ruby_command = ruby_command
+          @bundler = bundler
+        end
+
+        def build_test_command(files, options = {})
+          cmd_parts = []
+
+          # Use bundler if available and requested
+          cmd_parts << "bundle exec" if @bundler && bundler_available?
+
+          # Ruby command
+          cmd_parts << @ruby_command
+
+          # Add test framework options
+          cmd_parts << "-Ilib:test" unless options[:no_load_path]
+
+          # Note: fail_fast is handled by test executor, not minitest
+          # We don't use minitest/fail_fast gem to avoid extra dependencies
+
+          # Add the test files
+          if files.is_a?(Array)
+            # Check if any file has a line number (file:line format)
+            has_line_numbers = files.any? { |f| f.match?(/:\d+$/) }
+
+            if has_line_numbers
+              # For files with line numbers, resolve to test names and filter
+              build_line_number_command(cmd_parts, files, options)
+            else
+              # Build a Ruby script that requires each file and fails on LoadError
+              requires_script = files.map do |f|
+                # Add ./ prefix if it's a relative path without one
+                path = f.start_with?("/", "./") ? f : "./#{f}"
+                # Escape the path for shell safety
+                escaped_path = path.gsub("'", "\\\\'")
+                "begin; require '#{escaped_path}'; rescue LoadError => e; STDERR.puts \\\"Failed to load #{escaped_path}: \\\" + e.message; exit(1); end"
+              end.join("; ")
+
+              # Build the script parts
+              script_parts = []
+              # Inject ARGV with --verbose for Minitest if profile is requested
+              # (Ruby's --verbose flag only sets $VERBOSE, doesn't enable Minitest verbose mode)
+              script_parts << "ARGV.replace(['--verbose'])" if options[:profile]
+              script_parts << requires_script
+              script_parts << "exit_code = Minitest.autorun"
+              script_parts << "exit(exit_code)"
+
+              # Execute the requires and then run Minitest
+              cmd_parts << "-e"
+              # Use double quotes to wrap the entire script
+              cmd_parts << "\"#{script_parts.join("; ")}\""
+            end
+          elsif files.match?(/:\d+$/)
+            # Check if single file has line number
+            build_line_number_command(cmd_parts, [files], options)
+          elsif options[:profile]
+            # Single file without line number
+            cmd_parts << "-e"
+            escaped_path = files.gsub("'", "\\\\'")
+            path = files.start_with?("/", "./") ? escaped_path : "./#{escaped_path}"
+            cmd_parts << "\"ARGV.replace(['--verbose']); require '#{path}'; exit_code = Minitest.autorun; exit(exit_code)\""
+          # Inject ARGV with --verbose for Minitest profiling
+          else
+            # Just pass file as argument (Minitest autoruns)
+            cmd_parts << files
+          end
+
+          # Add any extra arguments
+          if options[:args]
+            cmd_parts.concat(Array(options[:args]))
+          end
+
+          cmd_parts.join(" ")
+        end
+
+        def build_single_file_command(file, options = {})
+          # Single file uses the same logic as multiple files
+          build_test_command(file, options)
+        end
+
+        def build_pattern_command(pattern)
+          cmd = []
+          cmd << "bundle exec" if @bundler && bundler_available?
+          cmd << @ruby_command
+          cmd << "-Ilib:test"
+          cmd << "-e"
+          cmd << %{'Dir.glob("#{pattern}").each { |f| require f }'}
+
+          cmd.join(" ")
+        end
+
+        private
+
+        def build_line_number_command(cmd_parts, files, options = {})
+          # For files with line numbers, we need to:
+          # 1. Load each file
+          # 2. Resolve line numbers to test names
+          # 3. Filter using --name option
+
+          file_requires = []
+          test_names = []
+
+          files.each do |file_with_line|
+            parsed = LineNumberResolver.parse_file_with_line(file_with_line)
+            file_path = parsed[:file]
+            line_number = parsed[:line]
+
+            # Add ./ prefix if it's a relative path without one
+            path = file_path.start_with?("/", "./") ? file_path : "./#{file_path}"
+            escaped_path = path.gsub("'", "\\\\'")
+
+            # Always require the file
+            file_requires << "require '#{escaped_path}'"
+
+            # If there's a line number, resolve it to a test name
+            if line_number
+              test_name = LineNumberResolver.resolve_test_at_line(file_path, line_number)
+              if test_name
+                test_names << test_name
+              end
+            end
+          end
+
+          # Build the command
+          script_parts = []
+
+          # Require all files
+          script_parts << file_requires.join("; ")
+
+          # Set up ARGV with --name filter and --verbose if needed
+          argv_args = []
+          argv_args << "--verbose" if options[:profile]
+          if test_names.any?
+            # Create a regex pattern that matches any of the test names
+            pattern = test_names.map { |name| Regexp.escape(name) }.join("|")
+            argv_args << "--name"
+            argv_args << "/#{pattern}/"
+          end
+          script_parts << "ARGV.replace([#{argv_args.map { |a| "'#{a}'" }.join(", ")}])" if argv_args.any?
+
+          # Run Minitest
+          script_parts << "exit_code = Minitest.autorun"
+          script_parts << "exit(exit_code)"
+
+          # Add to command
+          cmd_parts << "-e"
+          cmd_parts << "\"#{script_parts.join("; ")}\""
+        end
+
+        def bundler_available?
+          @bundler_available ||= system("which bundle > /dev/null 2>&1")
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Ace
+  module TestRunner
+    module Atoms
+      class LazyLoader
+        class << self
+          def load_formatter(format)
+            case format
+            when "json"
+              require_relative "../formatters/json_formatter"
+              Formatters::JsonFormatter
+            when "markdown"
+              require_relative "../formatters/markdown_formatter"
+              Formatters::MarkdownFormatter
+            when "progress"
+              require_relative "../formatters/progress_formatter"
+              Formatters::ProgressFormatter
+            when "progress-file"
+              require_relative "../formatters/progress_file_formatter"
+              Formatters::ProgressFileFormatter
+            else
+              raise ArgumentError, "Unknown format: #{format}"
+            end
+          end
+
+          def load_molecule(name)
+            case name
+            when :pattern_resolver
+              require_relative "../molecules/pattern_resolver"
+              Molecules::PatternResolver
+            when :config_loader
+              require_relative "../molecules/config_loader"
+              Molecules::ConfigLoader
+            when :deprecation_fixer
+              require_relative "../molecules/deprecation_fixer"
+              Molecules::DeprecationFixer
+            when :rake_integration
+              require_relative "../molecules/rake_integration"
+              Molecules::RakeIntegration
+            else
+              raise ArgumentError, "Unknown molecule: #{name}"
+            end
+          end
+
+          def load_organism(name)
+            case name
+            when :report_generator
+              require_relative "../organisms/report_generator"
+              Organisms::ReportGenerator
+            when :agent_reporter
+              require_relative "../organisms/agent_reporter"
+              Organisms::AgentReporter
+            else
+              raise ArgumentError, "Unknown organism: #{name}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+module Ace
+  module TestRunner
+    module Atoms
+      # Resolves line numbers to test method names
+      module LineNumberResolver
+        module_function
+
+        # Given a file and line number, find the test method name
+        # Returns the test name or nil if not found
+        def resolve_test_at_line(file_path, line_number)
+          return nil unless File.exist?(file_path)
+
+          content = File.read(file_path)
+          lines = content.split("\n")
+
+          # Find all test methods and their line ranges
+          test_methods = extract_test_methods(lines)
+
+          # Find the test that contains the specified line
+          test_methods.find do |test|
+            line_number >= test[:start_line] && line_number <= test[:end_line]
+          end&.fetch(:name)
+        end
+
+        # Extract test method names and their line ranges from file content
+        def extract_test_methods(lines)
+          test_methods = []
+          current_test = nil
+
+          lines.each_with_index do |line, index|
+            line_number = index + 1
+
+            # Match test method definitions: def test_something or test "something"
+            if line =~ /^\s*(def\s+(test_\w+)|test\s+["'](.+)["']\s+do)/
+              test_name = $2 || $3 # Either def test_name or test "name"
+
+              # Convert test "name" to test_name format for minitest --name option
+              test_name = test_name.gsub(/\s+/, "_") if test_name && test_name.include?(" ")
+
+              # Close previous test if any
+              if current_test
+                current_test[:end_line] = line_number - 1
+                test_methods << current_test
+              end
+
+              current_test = {
+                name: test_name,
+                start_line: line_number,
+                end_line: lines.size  # Default to end of file
+              }
+            elsif line =~ /^\s*end\s*(#.*)?$/ && current_test
+              # Found an end keyword - could be end of test method
+              # Simple heuristic: if we're at the same or less indentation level, close the test
+              current_indent = line[/^\s*/].length
+
+              if current_indent <= 2 # Assuming test methods are indented at most 2 spaces
+                current_test[:end_line] = line_number
+                test_methods << current_test
+                current_test = nil
+              end
+            end
+          end
+
+          # Close last test if still open
+          if current_test
+            current_test[:end_line] = lines.size
+            test_methods << current_test
+          end
+
+          test_methods
+        end
+
+        # Given "file.rb:123", split into file and line number
+        def parse_file_with_line(file_with_line)
+          if file_with_line =~ /^(.+):(\d+)$/
+            {file: $1, line: $2.to_i}
+          else
+            {file: file_with_line, line: nil}
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require "ace/support/config"
+
+module Ace
+  module TestRunner
+    module Atoms
+      # Resolves canonical test report directories.
+      module ReportDirectoryResolver
+        module_function
+
+        DEFAULT_REPORT_ROOT = ".ace-local/test/reports"
+
+        def resolve_report_root(raw_report_dir, explicit_cli_override:, start_path:)
+          root = raw_report_dir.to_s.strip
+          root = DEFAULT_REPORT_ROOT if root.empty?
+
+          return File.expand_path(root, start_path) if explicit_cli_override
+
+          project_root = Ace::Support::Config.find_project_root(start_path: start_path)
+          base = project_root || start_path
+          File.expand_path(root, base)
+        end
+
+        def infer_package_name(package_dir:, test_files:, cwd:)
+          if package_dir && !package_dir.to_s.empty?
+            return File.basename(File.expand_path(package_dir))
+          end
+
+          first = Array(test_files).first
+          if first && (match = first.match(%r{\A(.+?)/test/}))
+            return File.basename(match[1])
+          end
+
+          File.basename(File.expand_path(cwd))
+        end
+
+        def short_package_name(package_name)
+          package_name.to_s.sub(/\Aace-/, "")
+        end
+
+        def resolve_package_report_dir(report_root:, package_name:)
+          File.join(report_root, short_package_name(package_name))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Ace
+  module TestRunner
+    module Atoms
+      module ReportPathResolver
+        module_function
+
+        REPORT_PRIORITY = [
+          "failures.json",
+          "summary.json",
+          "report.md",
+          "report.json",
+          "raw_output.txt"
+        ].freeze
+
+        # Resolves the best available report file path for a package
+        #
+        # The resolver checks for report files in the following priority order:
+        #   1. failures.json - Detailed failure information
+        #   2. summary.json - Summary of test results
+        #   3. report.md - Markdown formatted report
+        #   4. report.json - JSON formatted report
+        #   5. raw_output.txt - Raw test output
+        #
+        # @param package_path [String] The root path of the package
+        # @param report_root [String, nil] Centralized report root
+        # @param package_name [String, nil] Package name used for centralized lookup
+        # @return [String, nil] The absolute path to the best available report file, or nil if none exist
+        def call(package_path, report_root: nil, package_name: nil)
+          return nil unless package_path && Dir.exist?(package_path)
+
+          reports_dir = report_directory(package_path, report_root: report_root, package_name: package_name)
+          return nil unless reports_dir
+
+          REPORT_PRIORITY.each do |filename|
+            path = File.join(reports_dir, filename)
+            return path if File.exist?(path)
+          end
+
+          nil
+        end
+
+        def report_directory(package_path, report_root: nil, package_name: nil)
+          candidates(package_path, report_root, package_name).each do |dir|
+            return dir if Dir.exist?(dir)
+          end
+
+          nil
+        end
+
+        def candidates(package_path, report_root, package_name)
+          dirs = []
+
+          if report_root
+            short_name = package_name.to_s.sub(/\Aace-/, "")
+            short_name = File.basename(package_path).sub(/\Aace-/, "") if short_name.empty?
+            dirs << File.join(report_root, short_name, "latest")
+          end
+
+          dirs << File.join(package_path, "test-reports", "latest")
+          dirs.uniq
+        end
+      end
+    end
+  end
+end