ace-test-runner 0.18.1 → 0.19.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 97801800374ba4230c6d4821d63ebf69ea2f9376a85173538fe0fd9c96bd66d8
-  data.tar.gz: 447e4b7f920d3e0188e81c56bfe3226c5c6ac1688a72f08b5a3a2bfb3303048e
+  metadata.gz: 2e03df42988ad85fabb842d9f7a5c5c018fbe14d70e085b9892a234bd20edc84
+  data.tar.gz: 351b02463eee937bb30257ffcec182160b1925ac63a3347585fc335e7e12a0d5
 SHA512:
-  metadata.gz: 1b0e98327d7a0a312a604750106abb08c9ae498b2c354464ce3c1af31d9b5be1bf60203c19882a00233d6affab895b6f2dc3806fbb7f8013b891dbf34eb0f0aa
-  data.tar.gz: 06257fccd1041208bb10bc6ef7b0ccf22f05468d864ca354e371c88ab0eb1200e6a158766e3a625b46d1d7f1d89d78fa9dcbf0a040a705ad415fe7c56cacbe52
+  metadata.gz: 1113c8e85abf9352bf8bfeb10e1d563bb197a5fedebacd3bd934b945a9830ad312c2e830e0b93cd09d4bf038e9f4fd113b7179fbce210e0b8bc801a4d58cf29b
+  data.tar.gz: 5c14a5221c6c4f1af586eb8c7811a007d555a09697a491d3578e45ca99e53a3047c620a756aaed53ab31df6be082c7756caa590dbfed258fbd810be3d02325c9

data/CHANGELOG.md

@@ -7,6 +7,16 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.19.1] - 2026-03-29
+
+### Technical
+- Normalized published gem metadata so RubyGems and Ruby Toolbox use current release information instead of the 1980 fallback date.
+
+### Added
+- **ace-test-runner v0.19.0**: Added suite-level per-package timeout support via `ace-test-suite --timeout` and `test_suite.timeout`, allowing hung package runs to fail and free their worker slot instead of stalling the rest of the suite.
+
+### Fixed
+- **ace-test-runner v0.19.0**: Terminate active package process groups on suite timeout or interrupt so `ace-test-suite` no longer leaves orphaned `ace-test` subprocesses behind after stuck or cancelled runs.
 
 ## [0.18.1] - 2026-03-29
 

data/exe/ace-test-suite

@@ -38,6 +38,10 @@ parser = OptionParser.new do |opts|
     options[:group] = group
   end
 
+  opts.on("-t", "--timeout SEC", Integer, "Per-package timeout in seconds") do |timeout|
+    options[:timeout] = timeout
+  end
+
   opts.on("-v", "--verbose", "Show verbose output") do
     options[:verbose] = true
   end
@@ -57,6 +61,7 @@ parser = OptionParser.new do |opts|
     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 --timeout 10       Fail packages that run over 10s"
     puts "  $ ace-test-suite --group foundation Run only foundation group"
     puts "  $ ace-test-suite --verbose          Show detailed test output"
     exit 0
@@ -110,6 +115,10 @@ if options[:parallel]
   config["test_suite"]["max_parallel"] = options[:parallel]
 end
 
+if options[:timeout]
+  config["test_suite"]["timeout"] = options[:timeout]
+end
+
 if options[:group]
   config["test_suite"]["packages"].select! { |p| p["group"] == options[:group] }
   if config["test_suite"]["packages"].empty?

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

@@ -33,7 +33,10 @@ module Ace
           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)
+          process_monitor = ProcessMonitor.new(
+            @config.dig("test_suite", "max_parallel") || 10,
+            package_timeout: @config.dig("test_suite", "timeout")
+          )
 
           # Enrich packages with historical duration data for scheduling
           estimator = DurationEstimator.new(report_root: report_root)
@@ -69,13 +72,19 @@ module Ace
           display_manager.show_final_results
 
           # Aggregate results
-          aggregator = ResultAggregator.new(@packages, report_root: report_root)
+          aggregator = ResultAggregator.new(@packages, report_root: report_root, runtime_results: @results)
           summary = aggregator.aggregate
 
           display_manager.show_summary(summary)
 
           # Return exit code based on results
           (summary[:packages_failed] > 0) ? 1 : 0
+        rescue Interrupt
+          process_monitor&.stop_all(reason: :interrupt)
+          raise
+        rescue StandardError
+          process_monitor&.stop_all(reason: :error)
+          raise
         end
 
         private

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

@@ -2,6 +2,7 @@
 
 require "open3"
 require "json"
+require "timeout"
 
 module Ace
   module TestRunner
@@ -9,8 +10,11 @@ module Ace
       class ProcessMonitor
         attr_reader :processes, :max_parallel
 
-        def initialize(max_parallel = 10)
+        def initialize(max_parallel = 10, package_timeout: nil, termination_grace_period: 1.0, clock: nil)
           @max_parallel = max_parallel
+          @package_timeout = package_timeout
+          @termination_grace_period = termination_grace_period
+          @clock = clock || -> { Time.now }
           @processes = {}
           @queue = []
           @completed = []
@@ -33,8 +37,8 @@ module Ace
             "ACE_ASSIGN_ID" => nil,
             "ACE_ASSIGN_FORK_ROOT" => nil
           })
-          start_time = Time.now
-          stdin, stdout, stderr, thread = Open3.popen3(env, cmd, chdir: package["path"])
+          start_time = now
+          stdin, stdout, stderr, thread = Open3.popen3(env, *cmd, chdir: package["path"], pgroup: true)
 
           @processes[package["name"]] = {
             package: package,
@@ -45,10 +49,18 @@ module Ace
             start_time: start_time,
             callback: callback,
             output: +"",
+            stderr_output: +"",
             report_root: test_options["report_dir"],
             test_count: 0,
             tests_run: 0,
-            dots: +""
+            dots: +"",
+            timeout: @package_timeout,
+            pid: thread.pid,
+            pgid: thread.pid,
+            terminating: false,
+            timeout_triggered: false,
+            terminated_by: nil,
+            terminate_at: nil
           }
 
           # Initial callback
@@ -61,96 +73,32 @@ module Ace
             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
+            stdout_chunk = drain_stream(process_info[:stdout], process_info[:output])
+            stderr_chunk = drain_stream(process_info[:stderr], process_info[:stderr_output])
+
+            parse_progress(process_info, stdout_chunk) if stdout_chunk && !stdout_chunk.empty?
+
+            if callback && ((stdout_chunk && !stdout_chunk.empty?) || (stderr_chunk && !stderr_chunk.empty?))
+              elapsed = 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
+              }, stdout_chunk)
             end
 
+            enforce_timeout(process_info)
+
             # Check if process completed
             unless thread.alive?
-              elapsed = Time.now - process_info[:start_time]
+              elapsed = 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
+              collect_remaining_output(process_info)
+              results = build_results(process_info, elapsed)
+              close_streams(process_info)
 
               # Final callback
               if callback
@@ -164,6 +112,8 @@ module Ace
                   success: success_status,
                   exit_code: exit_status,
                   elapsed: elapsed,
+                  timed_out: process_info[:timeout_triggered],
+                  interrupted: process_info[:terminated_by] == :interrupt,
                   results: results
                 }, process_info[:output])
               end
@@ -188,6 +138,38 @@ module Ace
           !@processes.empty? || !@queue.empty?
         end
 
+        def stop_all(reason: :interrupt)
+          @queue.clear
+
+          @processes.each_value do |process_info|
+            terminate_process_group(process_info, signal: "TERM", reason: reason)
+          end
+
+          deadline = now + @termination_grace_period
+          while @processes.values.any? { |info| info[:thread].alive? } && now < deadline
+            sleep 0.05
+          end
+
+          @processes.each_value do |process_info|
+            next unless process_info[:thread].alive?
+
+            terminate_process_group(process_info, signal: "KILL", reason: reason)
+          end
+
+          @processes.each_value do |process_info|
+            begin
+              Timeout.timeout(0.5) { process_info[:thread].value if process_info[:thread].alive? }
+            rescue Timeout::Error, StandardError
+              nil
+            end
+
+            close_streams(process_info)
+          end
+
+          @processes.clear
+          @completed.clear
+        end
+
         def wait_all
           while running?
             check_processes
@@ -219,10 +201,144 @@ module Ace
             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(" ")
+          cmd_parts
+        end
+
+        def now
+          @clock.call
+        end
+
+        def enforce_timeout(process_info)
+          timeout = process_info[:timeout]
+          return unless timeout
+
+          elapsed = now - process_info[:start_time]
+
+          if !process_info[:timeout_triggered] && elapsed > timeout
+            process_info[:timeout_triggered] = true
+            process_info[:terminate_at] = now + @termination_grace_period
+            terminate_process_group(process_info, signal: "TERM", reason: :timeout)
+          elsif process_info[:timeout_triggered] && process_info[:thread].alive? && process_info[:terminate_at] && now >= process_info[:terminate_at]
+            terminate_process_group(process_info, signal: "KILL", reason: :timeout)
+            process_info[:terminate_at] = nil
+          end
+        end
+
+        def terminate_process_group(process_info, signal:, reason:)
+          process_info[:terminated_by] = reason
+          process_info[:terminating] = true
+          Process.kill(signal, -process_info[:pgid])
+        rescue Errno::ESRCH, Errno::EPERM
+          nil
+        end
+
+        def drain_stream(io, buffer)
+          return nil unless io && !io.closed?
+
+          chunk = +""
+          loop do
+            ready = IO.select([io], nil, nil, 0)
+            break unless ready
+
+            chunk << io.read_nonblock(4096)
+          end
+
+          buffer << chunk unless chunk.empty?
+          chunk
+        rescue IO::WaitReadable, EOFError
+          buffer << chunk unless chunk.empty?
+          chunk
+        rescue IOError
+          nil
+        end
+
+        def collect_remaining_output(process_info)
+          process_info[:output] << safe_read(process_info[:stdout])
+          process_info[:stderr_output] << safe_read(process_info[:stderr])
+        end
+
+        def safe_read(io)
+          return "" unless io && !io.closed?
+
+          io.read
+        rescue StandardError
+          ""
+        end
+
+        def close_streams(process_info)
+          %i[stdout stderr stdin].each do |stream|
+            begin
+              process_info[stream]&.close
+            rescue StandardError
+              nil
+            end
+          end
+        end
+
+        def build_results(process_info, elapsed)
+          return timeout_results(process_info, elapsed) if process_info[:timeout_triggered]
+          return interrupted_results(elapsed) if process_info[:terminated_by] == :interrupt
+          results = load_summary_results(process_info, elapsed)
+          return results if results
+
+          parse_results(process_info[:output])
+        end
+
+        def timeout_results(process_info, elapsed)
+          {
+            tests: 0,
+            assertions: 0,
+            failures: 0,
+            errors: 1,
+            duration: elapsed,
+            success: false,
+            error: "Timed out after #{process_info[:timeout]} seconds"
+          }
+        end
+
+        def interrupted_results(elapsed)
+          {
+            tests: 0,
+            assertions: 0,
+            failures: 0,
+            errors: 1,
+            duration: elapsed,
+            success: false,
+            error: "Interrupted before completion"
+          }
+        end
+
+        def load_summary_results(process_info, elapsed)
+          package = process_info[:package]
+          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
+          return nil unless summary_file && File.exist?(summary_file)
+
+          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
+          }
+
+          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
+
+          results
+        rescue JSON::ParserError
+          nil
         end
 
         def parse_progress(process_info, chunk)

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

@@ -8,9 +8,10 @@ module Ace
       class ResultAggregator
         attr_reader :packages
 
-        def initialize(packages, report_root: nil)
+        def initialize(packages, report_root: nil, runtime_results: {})
           @packages = packages
           @report_root = report_root
+          @runtime_results = runtime_results || {}
         end
 
         def aggregate
@@ -90,8 +91,7 @@ module Ace
                 }
               end
             else
-              # No summary file means tests didn't complete or save
-              {
+              runtime_result(package) || {
                 package: package["name"],
                 path: package["path"],
                 report_root: @report_root,
@@ -119,6 +119,32 @@ module Ace
           end
         end
 
+        def runtime_result(package)
+          status = @runtime_results[package["name"]]
+          return nil unless status && status[:completed]
+
+          results = status[:results] || {}
+          total = results[:tests] || 0
+          failures = results[:failures] || 0
+          errors = results[:errors] || 0
+          skipped = results[:skipped] || 0
+
+          {
+            package: package["name"],
+            path: package["path"],
+            report_root: @report_root,
+            success: status[:success],
+            error: results[:error],
+            total: total,
+            passed: total - failures - errors - skipped,
+            failed: failures,
+            errors: errors,
+            skipped: skipped,
+            duration: results[:duration] || status[:elapsed] || 0,
+            assertions: results[:assertions] || 0
+          }
+        end
+
         def generate_report(summary)
           report = []
           report << "# ACE Test Suite Report"

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

@@ -86,6 +86,7 @@ module Ace
 
           line = "#{icon}  #{elapsed}  #{name}  #{tests_col}  #{asserts_col}  #{fail_col}"
           line += "  #{skipped} skip" if skipped > 0
+          line += "  timeout" if status[:timed_out]
 
           puts line
         end

data/lib/ace/test_runner/version.rb

@@ -2,6 +2,6 @@
 
 module Ace
   module TestRunner
-    VERSION = '0.18.1'
+    VERSION = '0.19.1'
   end
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: ace-test-runner
 version: !ruby/object:Gem::Version
-  version: 0.18.1
+  version: 0.19.1
 platform: ruby
 authors:
 - Michal Czyz
 bindir: exe
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2026-03-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ace-support-cli