ace-test-runner 0.18.0

data/lib/ace/test_runner/suite/process_monitor.rb

@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+
+require "open3"
+require "json"
+
+module Ace
+  module TestRunner
+    module Suite
+      class ProcessMonitor
+        attr_reader :processes, :max_parallel
+
+        def initialize(max_parallel = 10)
+          @max_parallel = max_parallel
+          @processes = {}
+          @queue = []
+          @completed = []
+        end
+
+        def start_package(package, test_options, &callback)
+          # Queue the package if we're at max capacity
+          if @processes.size >= @max_parallel
+            @queue << {package: package, options: test_options, callback: callback}
+            callback.call(package, {status: :waiting}, nil) if callback
+            return
+          end
+
+          # Build command
+          cmd = build_command(package, test_options)
+
+          # Start the process
+          # Strip assignment context vars to prevent tests from resolving to wrong assignments
+          env = ENV.to_h.merge({
+            "ACE_ASSIGN_ID" => nil,
+            "ACE_ASSIGN_FORK_ROOT" => nil
+          })
+          start_time = Time.now
+          stdin, stdout, stderr, thread = Open3.popen3(env, cmd, chdir: package["path"])
+
+          @processes[package["name"]] = {
+            package: package,
+            thread: thread,
+            stdout: stdout,
+            stderr: stderr,
+            stdin: stdin,
+            start_time: start_time,
+            callback: callback,
+            output: +"",
+            report_root: test_options["report_dir"],
+            test_count: 0,
+            tests_run: 0,
+            dots: +""
+          }
+
+          # Initial callback
+          callback.call(package, {status: :running, start_time: start_time}, nil) if callback
+        end
+
+        def check_processes
+          @processes.each do |name, process_info|
+            package = process_info[:package]
+            thread = process_info[:thread]
+            callback = process_info[:callback]
+
+            # Read available output
+            begin
+              if IO.select([process_info[:stdout]], nil, nil, 0)
+                chunk = process_info[:stdout].read_nonblock(4096)
+                process_info[:output] << chunk
+
+                # Parse progress from output
+                parse_progress(process_info, chunk)
+
+                # Update display with progress
+                if callback
+                  elapsed = Time.now - process_info[:start_time]
+                  callback.call(package, {
+                    status: :running,
+                    progress: process_info[:tests_run],
+                    total: process_info[:test_count],
+                    dots: process_info[:dots],
+                    elapsed: elapsed
+                  }, chunk)
+                end
+              end
+            rescue IO::WaitReadable, EOFError
+              # No data available or stream closed
+            end
+
+            # Check if process completed
+            unless thread.alive?
+              elapsed = Time.now - process_info[:start_time]
+              exit_status = thread.value.exitstatus
+
+              # Get final output
+              remaining_output = begin
+                process_info[:stdout].read
+              rescue
+                ""
+              end
+              process_info[:output] << remaining_output
+
+              # Try to get accurate results from summary.json first
+              results = nil
+              reports_dir = Atoms::ReportPathResolver.report_directory(
+                package["path"],
+                report_root: process_info[:report_root],
+                package_name: package["name"]
+              )
+              summary_file = reports_dir ? File.join(reports_dir, "summary.json") : nil
+              if summary_file && File.exist?(summary_file)
+                begin
+                  json_data = JSON.parse(File.read(summary_file))
+                  results = {
+                    tests: json_data["total"] || 0,
+                    assertions: json_data["assertions"] || 0,
+                    failures: json_data["failed"] || 0,
+                    errors: json_data["errors"] || 0,
+                    duration: json_data["duration"] || elapsed,
+                    success: json_data["success"] || false
+                  }
+
+                  # Also try to get assertions from report.json if not in summary
+                  if results[:assertions] == 0
+                    report_file = File.join(reports_dir, "report.json")
+                    if File.exist?(report_file)
+                      report_data = JSON.parse(File.read(report_file))
+                      results[:assertions] = report_data.dig("result", "assertions") || 0
+                    end
+                  end
+                rescue JSON::ParserError
+                  # Fall back to parsing output
+                end
+              end
+
+              # Fall back to parsing output if no JSON data
+              results ||= parse_results(process_info[:output])
+
+              # Close streams
+              begin
+                process_info[:stdout].close
+              rescue
+                nil
+              end
+              begin
+                process_info[:stderr].close
+              rescue
+                nil
+              end
+              begin
+                process_info[:stdin].close
+              rescue
+                nil
+              end
+
+              # Final callback
+              if callback
+                # Use results[:success] from summary.json if available, otherwise check exit code
+                # This ensures the package status matches what ace-test actually reported
+                success_status = (!results[:success].nil?) ? results[:success] : (exit_status == 0)
+
+                callback.call(package, {
+                  status: :completed,
+                  completed: true,
+                  success: success_status,
+                  exit_code: exit_status,
+                  elapsed: elapsed,
+                  results: results
+                }, process_info[:output])
+              end
+
+              # Remove from active processes
+              @completed << name
+            end
+          end
+
+          # Remove completed processes
+          @completed.each { |name| @processes.delete(name) }
+          @completed.clear
+
+          # Start queued processes if we have capacity
+          while @processes.size < @max_parallel && !@queue.empty?
+            queued = @queue.shift
+            start_package(queued[:package], queued[:options], &queued[:callback])
+          end
+        end
+
+        def running?
+          !@processes.empty? || !@queue.empty?
+        end
+
+        def wait_all
+          while running?
+            check_processes
+            sleep 0.1
+          end
+        end
+
+        private
+
+        def build_command(package, options)
+          cmd_parts = ["ace-test"]
+
+          # Always run in single batch for suite execution
+          # This avoids nested group headers and improves performance
+          cmd_parts << "--run-in-single-batch"
+
+          # Add format (use progress if compact is specified since ace-test doesn't have compact format)
+          format = options["format"] || "progress"
+          format = "progress" if format == "compact"  # Handle legacy compact format
+          cmd_parts << "--format" << format
+
+          # Add other options
+          cmd_parts << "--no-save" unless options["save_reports"]
+          cmd_parts << "--fail-fast" if options["fail_fast"]
+          cmd_parts << "--no-color" unless options.fetch("color", true)
+          if options["report_dir"]
+            short_name = package["name"].to_s.sub(/\Aace-/, "")
+            pkg_report_dir = File.join(options["report_dir"], short_name)
+            cmd_parts << "--report-dir" << pkg_report_dir
+          end
+
+          # Build command string
+          # Note: Do NOT set CI=true here - respect the existing environment
+          # Tests that need CI-aware behavior should check ENV['CI'] directly
+          cmd_parts.join(" ")
+        end
+
+        def parse_progress(process_info, chunk)
+          # Count dots, F, E, S in the output for progress
+          dots = chunk.scan(/[.FES]/).join
+          process_info[:dots] << dots
+          process_info[:tests_run] += dots.length
+
+          # Try to extract total test count from output
+          if process_info[:test_count] == 0 && chunk =~ /Running (\d+)(?:\/\d+)? test files/
+            process_info[:test_count] = $1.to_i * 10  # Estimate tests per file
+          elsif chunk =~ /(\d+) tests?,/
+            process_info[:test_count] = $1.to_i
+          end
+        end
+
+        def parse_results(output)
+          # Look for summary line in output
+          if output =~ /(\d+) tests?, (\d+) assertions?, (\d+) failures?, (\d+) errors? \(([\d.]+)s\)/
+            {
+              tests: $1.to_i,
+              assertions: $2.to_i,
+              failures: $3.to_i,
+              errors: $4.to_i,
+              duration: $5.to_f,
+              success: $3.to_i == 0 && $4.to_i == 0
+            }
+          else
+            # Fallback to counting dots/F/E/S
+            dots = output.scan(/[.FES]/).join
+            {
+              tests: dots.length,
+              failures: dots.count("F"),
+              errors: dots.count("E"),
+              skipped: dots.count("S"),
+              success: !dots.include?("F") && !dots.include?("E")
+            }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/test_runner/suite/result_aggregator.rb

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Ace
+  module TestRunner
+    module Suite
+      class ResultAggregator
+        attr_reader :packages
+
+        def initialize(packages, report_root: nil)
+          @packages = packages
+          @report_root = report_root
+        end
+
+        def aggregate
+          results = collect_results
+
+          # Calculate assertion totals
+          total_assertions = 0
+          assertions_failed = 0
+
+          results.each do |r|
+            # Get assertions from either summary or report data
+            if r[:assertions]
+              total_assertions += r[:assertions]
+            elsif r[:report_data]
+              total_assertions += r[:report_data].dig(:result, :assertions) || 0
+            end
+          end
+
+          {
+            total_tests: results.sum { |r| r[:total] || 0 },
+            total_passed: results.sum { |r| r[:passed] || 0 },
+            total_failed: results.sum { |r| (r[:failed] || 0) + (r[:errors] || 0) },
+            total_skipped: results.sum { |r| r[:skipped] || 0 },
+            total_assertions: total_assertions,
+            assertions_failed: assertions_failed,
+            total_duration: results.map { |r| r[:duration] || 0 }.max,
+            packages_passed: results.count { |r| r[:success] },
+            packages_failed: results.count { |r| !r[:success] },
+            failed_packages: collect_failed_packages(results),
+            results: results
+          }
+        end
+
+        def collect_results
+          @packages.map do |package|
+            reports_dir = Atoms::ReportPathResolver.report_directory(
+              package["path"],
+              report_root: @report_root,
+              package_name: package["name"]
+            )
+            summary_path = reports_dir ? File.join(reports_dir, "summary.json") : nil
+
+            if summary_path && File.exist?(summary_path)
+              begin
+                data = JSON.parse(File.read(summary_path), symbolize_names: true)
+                data[:package] = package["name"]
+                data[:path] = package["path"]
+                data[:report_root] = @report_root
+
+                # Try to get assertions from report.json if not in summary
+                if !data[:assertions] || data[:assertions] == 0
+                  report_path = File.join(reports_dir, "report.json")
+                  if File.exist?(report_path)
+                    begin
+                      report_data = JSON.parse(File.read(report_path), symbolize_names: true)
+                      data[:assertions] = report_data.dig(:result, :assertions) || 0
+                      data[:report_data] = report_data
+                    rescue JSON::ParserError
+                      # Ignore if report.json can't be parsed
+                    end
+                  end
+                end
+
+                data
+              rescue JSON::ParserError => e
+                # If we can't parse the summary, create a failure result
+                {
+                  package: package["name"],
+                  path: package["path"],
+                  report_root: @report_root,
+                  success: false,
+                  error: "Failed to parse summary.json: #{e.message}",
+                  total: 0,
+                  passed: 0,
+                  failed: 0,
+                  errors: 1
+                }
+              end
+            else
+              # No summary file means tests didn't complete or save
+              {
+                package: package["name"],
+                path: package["path"],
+                report_root: @report_root,
+                success: false,
+                error: "No test results found (summary.json missing)",
+                total: 0,
+                passed: 0,
+                failed: 0,
+                errors: 1
+              }
+            end
+          end
+        end
+
+        def collect_failed_packages(results)
+          results.select { |r| !r[:success] }.map do |result|
+            {
+              name: result[:package],
+              path: result[:path],
+              report_root: result[:report_root] || @report_root,
+              failures: result[:failed] || 0,
+              errors: result[:errors] || 0,
+              error_message: result[:error]
+            }
+          end
+        end
+
+        def generate_report(summary)
+          report = []
+          report << "# ACE Test Suite Report"
+          report << ""
+          report << "## Summary"
+          report << ""
+
+          report << if summary[:packages_failed] == 0
+            "✅ **All tests passed!**"
+          else
+            "❌ **Some tests failed**"
+          end
+
+          report << ""
+          report << "- Packages: #{summary[:packages_passed]} passed, #{summary[:packages_failed]} failed"
+          report << "- Tests: #{summary[:total_tests]} total, #{summary[:total_passed]} passed, #{summary[:total_failed]} failed"
+          report << "- Duration: #{sprintf("%.2f", summary[:total_duration])}s"
+          report << ""
+
+          if summary[:failed_packages] && !summary[:failed_packages].empty?
+            report << "## Failed Packages"
+            report << ""
+
+            summary[:failed_packages].each do |pkg|
+              report << "### #{pkg[:name]}"
+              report << ""
+              report << "- Failures: #{pkg[:failures]}"
+              report << "- Errors: #{pkg[:errors]}"
+              report << "- Error: #{pkg[:error_message]}" if pkg[:error_message]
+              report << Ace::TestRunner::Molecules::FailedPackageReporter.format_for_markdown(pkg)
+              report << ""
+            end
+          end
+
+          report << "## Package Results"
+          report << ""
+          report << "| Package | Status | Tests | Passed | Failed | Skipped | Duration |"
+          report << "|---------|--------|-------|--------|--------|---------|----------|"
+
+          summary[:results].each do |result|
+            status = result[:success] ? "✅ Pass" : "❌ Fail"
+            report << "| #{result[:package]} | #{status} | #{result[:total]} | #{result[:passed]} | #{result[:failed] || 0} | #{result[:skipped] || 0} | #{sprintf("%.2f", result[:duration] || 0)}s |"
+          end
+
+          report.join("\n")
+        end
+
+        def save_report(summary, path = "test-suite-report.md")
+          File.write(path, generate_report(summary))
+          path
+        end
+      end
+    end
+  end
+end

data/lib/ace/test_runner/suite/simple_display_manager.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require_relative "display_helpers"
+
+module Ace
+  module TestRunner
+    module Suite
+      # SimpleDisplayManager provides line-by-line output without ANSI cursor control.
+      # This is the default display mode, optimized for piping and agent consumption.
+      #
+      # Unlike DisplayManager which uses ANSI escape codes to update lines in place,
+      # SimpleDisplayManager simply prints one line per package as it completes.
+      class SimpleDisplayManager
+        include DisplayHelpers
+
+        attr_reader :packages, :config, :start_time
+
+        def initialize(packages, config)
+          @packages = packages
+          @config = config
+          @package_status = {}
+          @start_time = Time.now
+          @use_color = config.dig("test_suite", "display", "color") != false
+          @package_width = calculate_package_width
+        end
+
+        # Print initial message showing how many packages will run
+        def initialize_display
+          puts "Running tests for #{@packages.size} packages..."
+        end
+
+        # Called when a package status changes. Prints a line when package completes.
+        def update_package(package, status, _output = nil)
+          @package_status[package["name"]] = status
+
+          # Only print when package completes
+          return unless status[:completed]
+
+          print_completion_line(package, status)
+        end
+
+        # No-op for simple mode - we don't need live updates
+        def refresh
+          # Intentionally empty - simple mode doesn't refresh
+        end
+
+        # No-op for simple mode - results already printed as packages complete
+        def show_final_results
+          # Intentionally empty - completion lines already printed in update_package
+        end
+
+        # Display the summary section using shared helpers
+        def show_summary(summary)
+          render_summary(summary, @start_time, separator)
+        end
+
+        private
+
+        # Print completion line with columnar format for easy scanning:
+        # STATUS  TIME  PACKAGE                    TESTS    ASSERTS    FAIL
+        # OK     1.57s  ace-handbook                   1          3       0
+        def print_completion_line(package, status)
+          results = status[:results] || {}
+          duration = results[:duration] || status[:elapsed] || 0
+          elapsed = sprintf("%5.2fs", duration)
+
+          tests = results[:tests] || 0
+          assertions = results[:assertions] || 0
+          failures = results[:failures] || 0
+          errors = results[:errors] || 0
+          skipped = results[:skipped] || 0
+
+          if status[:success]
+            icon = package_status_icon(true, skipped)
+            failure_count = failures
+          else
+            icon = package_status_icon(false, 0)
+            failure_count = failures + errors
+          end
+
+          # Format: ICON  TIME  PACKAGE  TESTS  ASSERTS  FAIL [SKIP]
+          name = package["name"].ljust(@package_width)
+          tests_col = "#{tests.to_s.rjust(4)} tests"
+          asserts_col = "#{assertions.to_s.rjust(5)} asserts"
+          fail_col = "#{failure_count.to_s.rjust(3)} fail"
+
+          line = "#{icon}  #{elapsed}  #{name}  #{tests_col}  #{asserts_col}  #{fail_col}"
+          line += "  #{skipped} skip" if skipped > 0
+
+          puts line
+        end
+
+        def package_status_icon(success, skipped_count)
+          return color("✗", :red) unless success
+          (skipped_count > 0) ? color("?", :yellow) : color("✓", :green)
+        end
+
+        def separator
+          "=" * 65
+        end
+
+        def color(text, color_name)
+          return text unless @use_color
+
+          colors = {
+            green: "\033[32m",
+            red: "\033[31m",
+            yellow: "\033[33m",
+            reset: "\033[0m"
+          }
+
+          "#{colors[color_name]}#{text}#{colors[:reset]}"
+        end
+
+        def calculate_package_width
+          max_length = @packages.map { |p| p["name"].length }.max || 0
+          [max_length, 15].max  # Minimum width of 15 for readability
+        end
+      end
+    end
+  end
+end

data/lib/ace/test_runner/suite.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require_relative "suite/display_helpers"
+require_relative "suite/duration_estimator"
+require_relative "suite/orchestrator"
+require_relative "suite/process_monitor"
+require_relative "suite/display_manager"
+require_relative "suite/simple_display_manager"
+require_relative "suite/result_aggregator"
+
+module Ace
+  module TestRunner
+    module Suite
+      class Error < StandardError; end
+
+      def self.run(config)
+        orchestrator = Orchestrator.new(config)
+        orchestrator.run
+      end
+    end
+  end
+end

data/lib/ace/test_runner/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Ace
+  module TestRunner
+    VERSION = "0.18.0"
+  end
+end

data/lib/ace/test_runner.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "ace/core"
+# Don't require ace/test_support here - it loads minitest/autorun which causes double runs
+# Test files will require it themselves
+
+# Only require minitest when actually running tests
+# require "minitest" is done by test files or CommandBuilder
+# require "minitest/reporters" is done when needed
+require "open3"
+require "json"
+require "yaml"
+require "fileutils"
+require "time"
+
+require_relative "test_runner/version"
+
+# CLI and commands
+require_relative "test_runner/cli"
+
+# Models - Pure data structures
+require_relative "test_runner/models/test_result"
+require_relative "test_runner/models/test_failure"
+require_relative "test_runner/models/test_configuration"
+require_relative "test_runner/models/test_report"
+
+# Atoms - Basic utilities (always needed)
+require_relative "test_runner/atoms/test_detector"
+require_relative "test_runner/atoms/command_builder"
+require_relative "test_runner/atoms/result_parser"
+require_relative "test_runner/atoms/timestamp_generator"
+require_relative "test_runner/atoms/lazy_loader"
+require_relative "test_runner/atoms/report_path_resolver"
+require_relative "test_runner/atoms/report_directory_resolver"
+
+# Molecules - Core operations (always needed for basic test running)
+require_relative "test_runner/molecules/test_executor"
+require_relative "test_runner/molecules/failure_analyzer"
+require_relative "test_runner/molecules/report_storage"
+require_relative "test_runner/molecules/config_loader"
+require_relative "test_runner/molecules/pattern_resolver"
+require_relative "test_runner/molecules/cli_argument_parser"
+require_relative "test_runner/molecules/failed_package_reporter"
+# Other molecules loaded lazily (deprecation_fixer, rake_integration)
+
+# Formatters - Load only base formatter, others loaded on demand
+require_relative "test_runner/formatters/base_formatter"
+# Other formatters loaded lazily via LazyLoader
+
+# Organisms - Core orchestrators always needed for test execution
+require_relative "test_runner/organisms/test_orchestrator"
+require_relative "test_runner/organisms/report_generator"
+# Agent reporter loaded lazily when needed
+
+module Ace
+  module TestRunner
+    class Error < StandardError; end
+
+    # Define module namespaces
+    module Commands; end
+
+    class << self
+      def run(options = {})
+        orchestrator = Organisms::TestOrchestrator.new(options)
+        orchestrator.run
+      end
+    end
+  end
+end