ace-test-runner 0.18.0

data/lib/ace/test_runner/rake_task.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+require "rake"
+require "rake/tasklib"
+
+module Ace
+  module TestRunner
+    # Custom Rake task that uses ace-test instead of standard Minitest runner
+    # This allows seamless integration with existing Rake workflows
+    class RakeTask < Rake::TaskLib
+      attr_accessor :name, :description, :libs, :pattern, :verbose, :format,
+        :warning, :loader, :options, :test_files
+
+      def initialize(name = :test)
+        @name = name
+        @description = "Run tests with ace-test"
+        @libs = %w[test lib]
+        @pattern = "test/**/*_test.rb"
+        @verbose = false
+        @format = nil
+        @warning = false
+        @loader = nil
+        @options = nil
+        @test_files = nil
+
+        yield self if block_given?
+        define
+      end
+
+      def define
+        desc @description
+        task @name do
+          run_tests
+        end
+      end
+
+      private
+
+      def run_tests
+        # Build ace-test command
+        command = build_command
+
+        # Execute ace-test with sanitized environment
+        # Strip assignment context vars to prevent tests from resolving to wrong assignments
+        puts command if verbose
+        env = ENV.to_h.merge({
+          "ACE_ASSIGN_ID" => nil,
+          "ACE_ASSIGN_FORK_ROOT" => nil
+        })
+        success = system(env, command)
+
+        # Exit with proper code for CI/CD
+        exit(1) unless success
+      end
+
+      def build_command
+        cmd = ["ace-test"]
+
+        # Add format if specified
+        cmd << "--format" << format if format
+
+        # Add verbose flag
+        cmd << "--verbose" if verbose
+
+        # Handle TEST environment variable (specific test file)
+        if ENV["TEST"]
+          cmd << ENV["TEST"]
+        elsif test_files
+          # Handle explicit test files
+          cmd.concat(Array(test_files))
+        elsif pattern
+          # Use pattern to find files (ace-test will handle this internally)
+          # For now, we'll let ace-test use its default detection
+        end
+
+        # Handle TESTOPTS environment variable
+        if ENV["TESTOPTS"]
+          # Parse TESTOPTS and add to command
+          opts = ENV["TESTOPTS"].split(/\s+/)
+          cmd.concat(opts)
+        end
+
+        # Add any additional options
+        cmd.concat(Array(options)) if options
+
+        cmd.join(" ")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module Ace
+  module TestRunner
+    module Suite
+      # DisplayHelpers provides shared formatting methods for display managers.
+      # This module centralizes common output formatting logic used by both
+      # SimpleDisplayManager (line-by-line) and DisplayManager (animated).
+      #
+      # == Interface Requirements
+      #
+      # Including classes must implement:
+      #   color(text, color_name) - Apply color to text (or return text unchanged)
+      #     @param text [String] the text to colorize
+      #     @param color_name [Symbol] one of :green, :red, :yellow
+      #     @return [String] colorized text or plain text
+      #
+      # This module provides a `colorize` wrapper that delegates to `color()`.
+      # Internal methods use `colorize()` for consistency; including classes
+      # only need to implement `color()`.
+      #
+      module DisplayHelpers
+        # Render the overall summary section
+        # @param summary [Hash] summary data from orchestrator
+        # @param start_time [Time] when the test run started
+        # @param separator [String] visual separator line
+        def render_summary(summary, start_time, separator)
+          puts
+          puts separator
+
+          total_duration = Time.now - start_time
+          total_skipped = summary[:total_skipped] || 0
+
+          # Show packages with skipped tests first (least important, scrolls away)
+          render_skipped_packages(summary, total_skipped)
+
+          # Show failed packages (important but less than status)
+          render_failed_packages(summary)
+
+          # Duration
+          puts "Duration:    #{sprintf("%.2f", total_duration)}s"
+
+          # Stats (packages, tests, assertions)
+          puts "Packages:    #{summary[:packages_passed]} passed, #{summary[:packages_failed]} failed"
+          render_tests_line(summary, total_skipped)
+          render_assertions_line(summary)
+
+          # Overall status message LAST (most visible)
+          puts
+          render_status_message(summary[:packages_failed], total_skipped)
+
+          puts separator
+        end
+
+        private
+
+        def render_status_message(packages_failed, total_skipped)
+          if packages_failed == 0 && total_skipped == 0
+            puts colorize("✓ ALL TESTS PASSED", :green)
+          elsif packages_failed == 0 && total_skipped > 0
+            puts colorize("✓ ALL TESTS PASSED", :green)
+          else
+            puts colorize("✗ SOME TESTS FAILED", :red)
+          end
+        end
+
+        def render_tests_line(summary, total_skipped)
+          return unless summary[:total_tests] > 0
+
+          if total_skipped > 0
+            puts "Tests:       #{summary[:total_passed]} passed, #{summary[:total_failed]} failed, #{total_skipped} skipped"
+          else
+            puts "Tests:       #{summary[:total_passed]} passed, #{summary[:total_failed]} failed"
+          end
+        end
+
+        def render_assertions_line(summary)
+          return unless summary[:total_assertions] && summary[:total_assertions] > 0
+
+          assertions_failed = summary[:assertions_failed] || 0
+          assertions_passed = summary[:total_assertions] - assertions_failed
+          puts "Assertions:  #{assertions_passed} passed, #{assertions_failed} failed"
+        end
+
+        def render_failed_packages(summary)
+          return unless summary[:failed_packages] && !summary[:failed_packages].empty?
+
+          puts
+          puts "Failed packages:"
+          summary[:failed_packages].each do |pkg|
+            puts "  - #{pkg[:name]}: #{pkg[:failures]} failures, #{pkg[:errors]} errors"
+            puts Ace::TestRunner::Molecules::FailedPackageReporter.format_for_display(pkg)
+          end
+        end
+
+        def render_skipped_packages(summary, total_skipped)
+          return unless total_skipped > 0
+
+          packages_with_skips = summary[:results].select { |r| (r[:skipped] || 0) > 0 }
+          return if packages_with_skips.empty?
+
+          skip_parts = packages_with_skips.map { |pkg| "#{pkg[:package]} (#{pkg[:skipped]})" }
+          puts "Skipped: #{skip_parts.join(", ")}"
+          puts
+        end
+
+        # Colorize text - must be implemented by including class
+        # @param text [String] text to colorize
+        # @param color_name [Symbol] color name (:green, :red, :yellow)
+        # @return [String] colorized text or plain text if color disabled
+        def colorize(text, color_name)
+          color(text, color_name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,204 @@
+# frozen_string_literal: true
+
+require_relative "display_helpers"
+
+module Ace
+  module TestRunner
+    module Suite
+      class DisplayManager
+        include DisplayHelpers
+
+        attr_reader :packages, :config, :lines, :start_time
+
+        def initialize(packages, config)
+          @packages = packages
+          @config = config
+          @lines = {}
+          @package_status = {}
+          @start_time = Time.now
+          @use_color = config.dig("test_suite", "display", "color") != false
+          @last_refresh = Time.now
+          @refresh_interval = config.dig("test_suite", "display", "update_interval") || 0.1
+        end
+
+        def initialize_display
+          # Clear screen like Ctrl+L (preserves scrollback)
+          print "\033[H\033[J"
+
+          # Print header
+          puts separator
+          puts "  ACE Test Suite Runner - Running #{@packages.size} packages"
+          puts separator
+          puts
+
+          # Reserve lines for each package
+          @packages.each_with_index do |package, index|
+            @lines[package["name"]] = index + 5  # Account for header lines
+            @package_status[package["name"]] = {status: :waiting}
+            print_package_line(package["name"])
+          end
+
+          # Print footer space
+          puts
+          puts
+          @footer_line = @lines.values.max + 3
+        end
+
+        def update_package(package, status, output = nil)
+          @package_status[package["name"]] = status
+          print_package_line(package["name"])
+          update_footer
+        end
+
+        def refresh
+          # Only refresh if enough time has passed
+          return if Time.now - @last_refresh < @refresh_interval
+
+          @package_status.each do |name, _status|
+            print_package_line(name)
+          end
+          update_footer
+          @last_refresh = Time.now
+        end
+
+        # Finalize display by moving cursor past the display area.
+        # In progress mode, package results are already shown inline during updates,
+        # so we skip redrawing the results table. The overall summary is handled by show_summary.
+        def finalize_display
+          move_to_line(@footer_line + 1)
+          puts
+        end
+
+        # Alias for backward compatibility
+        alias_method :show_final_results, :finalize_display
+
+        # Display the summary section using shared helpers
+        def show_summary(summary)
+          render_summary(summary, @start_time, separator)
+        end
+
+        private
+
+        def print_package_line(name)
+          status = @package_status[name]
+          line = @lines[name]
+
+          move_to_line(line)
+          print "\033[K"  # Clear line
+
+          # Format package name (fixed width, no brackets)
+          pkg_name = name.ljust(25)
+
+          case status[:status]
+          when :waiting
+            icon = color("·", :gray)
+            elapsed = "  0.00s"
+            progress = "[············]  waiting"
+            print "#{icon}  #{elapsed}  #{pkg_name}  #{progress}"
+
+          when :running
+            icon = color("⋯", :cyan)
+            duration = status.dig(:results, :duration) || status[:elapsed] || 0
+            elapsed = sprintf("%5.2fs", duration)
+            progress_bar = build_progress_bar(status)
+            count = if status[:total] && status[:total] > 0
+              "#{status[:progress]}/#{status[:total]}"
+            else
+              "running"
+            end
+            print "#{icon}  #{elapsed}  #{pkg_name}  #{progress_bar}  #{count}"
+
+          when :completed
+            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]
+            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_text = "#{icon}  #{elapsed}  #{pkg_name}  #{tests_col}  #{asserts_col}  #{fail_col}"
+            line_text += "  #{skipped} skip" if skipped > 0
+
+            print line_text
+          end
+        end
+
+        # Determines the appropriate status icon for a package
+        # Returns ? (yellow) for successful packages with skipped tests (informational)
+        # Returns ✓ (green) for successful packages without skipped tests
+        # Returns ✗ (red) for failed packages
+        def package_status_icon(success, skipped_count)
+          return color("✗", :red) unless success
+          (skipped_count > 0) ? color("?", :yellow) : color("✓", :green)
+        end
+
+        def build_progress_bar(status)
+          bar_width = 13
+          if status[:total] && status[:total] > 0
+            progress = status[:progress] || 0
+            filled = (progress.to_f / status[:total] * bar_width).round
+          else
+            # Animate based on elapsed time if no total
+            duration = status.dig(:results, :duration) || status[:elapsed] || 0
+            filled = ((duration % 3) * bar_width / 3).round
+          end
+
+          filled = [filled, bar_width].min
+          empty = bar_width - filled
+
+          "[" + color("▓" * filled, :green) + "░" * empty + "]"
+        end
+
+        def update_footer
+          move_to_line(@footer_line)
+          print "\033[K"
+
+          active = @package_status.count { |_, s| s[:status] == :running }
+          completed = @package_status.count { |_, s| s[:status] == :completed }
+          waiting = @package_status.count { |_, s| s[:status] == :waiting }
+
+          print "Active: #{active} | Completed: #{completed} | Waiting: #{waiting}"
+        end
+
+        def move_to_line(line)
+          print "\033[#{line};1H"
+        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",
+            cyan: "\033[36m",
+            gray: "\033[90m",
+            reset: "\033[0m"
+          }
+
+          "#{colors[color_name]}#{text}#{colors[:reset]}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Ace
+  module TestRunner
+    module Suite
+      # Estimates expected test duration for packages based on historical data.
+      # Used by Orchestrator to schedule slowest packages first, preventing
+      # them from becoming bottlenecks at the end of parallel test runs.
+      class DurationEstimator
+        def initialize(report_root: nil)
+          @report_root = report_root
+        end
+
+        # Read historical duration from package's latest summary.json
+        #
+        # @param package [Hash] Package config with "path" key
+        # @return [Float, nil] Duration in seconds, or nil if unavailable
+        def estimate(package)
+          reports_dir = Atoms::ReportPathResolver.report_directory(
+            package["path"],
+            report_root: @report_root,
+            package_name: package["name"]
+          )
+          return nil unless reports_dir
+
+          summary_file = File.join(reports_dir, "summary.json")
+          return nil unless File.exist?(summary_file)
+
+          data = JSON.parse(File.read(summary_file))
+          data["duration"]
+        rescue JSON::ParserError, Errno::ENOENT, Errno::EACCES
+          nil
+        end
+
+        # Enrich packages with expected_duration from historical data
+        #
+        # @param packages [Array<Hash>] Package configs
+        # @return [Array<Hash>] Same packages with expected_duration added
+        def enrich_packages(packages)
+          packages.each do |pkg|
+            pkg["expected_duration"] = estimate(pkg) || 0
+          end
+          packages
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require "open3"
+require "pathname"
+
+module Ace
+  module TestRunner
+    module Suite
+      class Orchestrator
+        attr_reader :config, :packages, :results, :running_processes
+
+        def initialize(config)
+          @config = config
+          @packages = config.dig("test_suite", "packages") || []
+          @results = {}
+          @running_processes = {}
+          @completed_packages = []
+          @waiting_packages = []
+          @failed_packages = []
+
+          # Use ace-config's project root detection
+          require "ace/support/config"
+          @project_root = Ace::Support::Config.find_project_root
+
+          # Resolve package paths relative to project root
+          resolve_package_paths! if @project_root
+        end
+
+        def run
+          validate_packages!
+          test_options = (@config.dig("test_suite", "test_options") || {}).dup
+          report_root = normalize_report_root(test_options["report_dir"])
+          test_options["report_dir"] = report_root if report_root
+
+          display_manager = create_display_manager
+          process_monitor = ProcessMonitor.new(@config.dig("test_suite", "max_parallel") || 10)
+
+          # Enrich packages with historical duration data for scheduling
+          estimator = DurationEstimator.new(report_root: report_root)
+          estimator.enrich_packages(@packages)
+
+          # Sort by expected duration (descending), then priority (ascending)
+          # This ensures slowest packages start first, preventing end-of-run bottlenecks
+          sorted_packages = @packages.sort_by { |p| [-(p["expected_duration"] || 0), p["priority"] || 999] }
+
+          # Initialize display
+          display_manager.initialize_display
+
+          # Start processes
+          sorted_packages.each do |package|
+            process_monitor.start_package(package, test_options) do |pkg, status, output|
+              display_manager.update_package(pkg, status, output)
+
+              if status[:completed]
+                @completed_packages << pkg
+                @results[pkg["name"]] = status
+              end
+            end
+          end
+
+          # Wait for all processes to complete
+          while process_monitor.running?
+            process_monitor.check_processes
+            display_manager.refresh
+            sleep(@config.dig("test_suite", "display", "update_interval") || 0.1)
+          end
+
+          # Final display
+          display_manager.show_final_results
+
+          # Aggregate results
+          aggregator = ResultAggregator.new(@packages, report_root: report_root)
+          summary = aggregator.aggregate
+
+          display_manager.show_summary(summary)
+
+          # Return exit code based on results
+          (summary[:packages_failed] > 0) ? 1 : 0
+        end
+
+        private
+
+        def validate_packages!
+          @packages.each do |package|
+            unless Dir.exist?(package["path"])
+              raise "Package directory not found: #{package["path"]} for #{package["name"]}"
+            end
+          end
+        end
+
+        def resolve_package_paths!
+          @packages.each do |package|
+            # If path is relative (doesn't start with /), resolve it relative to project root
+            if package["path"] && !package["path"].start_with?("/")
+              package["path"] = File.join(@project_root, package["path"])
+            end
+          end
+        end
+
+        # Select display manager based on --progress flag.
+        # Default: SimpleDisplayManager (line-by-line, pipe-friendly)
+        # With --progress: DisplayManager (animated ANSI progress bars)
+        def create_display_manager
+          if @config.dig("test_suite", "progress")
+            DisplayManager.new(@packages, @config)
+          else
+            SimpleDisplayManager.new(@packages, @config)
+          end
+        end
+
+        def normalize_report_root(report_root)
+          return nil if report_root.nil? || report_root.to_s.empty?
+          return report_root if Pathname.new(report_root).absolute?
+
+          File.expand_path(report_root, @project_root || Dir.pwd)
+        end
+      end
+    end
+  end
+end