ace-test-runner 0.18.1 → 0.25.5

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, exit_status)
+              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
@@ -200,8 +182,8 @@ module Ace
         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
+          # Suite package execution intentionally bypasses grouped mode so each
+          # package runs its full target scope as one batch under suite orchestration.
           cmd_parts << "--run-in-single-batch"
 
           # Add format (use progress if compact is specified since ace-test doesn't have compact format)
@@ -219,10 +201,176 @@ 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(" ")
+          target = options["target"]
+          cmd_parts << target if target && !target.to_s.empty?
+
+          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, exit_status)
+          return timeout_results(process_info, elapsed) if process_info[:timeout_triggered]
+          return interrupted_results(elapsed) if process_info[:terminated_by] == :interrupt
+          fresh_summary = load_summary_results(process_info, elapsed)
+          return fresh_summary if exit_status == 0 && fresh_summary
+          return failed_process_results(process_info, elapsed, exit_status, fresh_summary) if exit_status != 0
+
+          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 failed_process_results(process_info, elapsed, exit_status, fresh_summary)
+          return fresh_summary if fresh_summary && fresh_summary[:success] == false
+
+          parsed = parse_results([process_info[:output], process_info[:stderr_output]].join("\n"))
+          parsed[:duration] ||= elapsed
+          parsed[:success] = false
+          parsed[:error] ||= failure_message_for(process_info, exit_status)
+          parsed[:errors] = 1 if parsed[:failures].to_i == 0 && parsed[:errors].to_i == 0
+          parsed
+        end
+
+        def failure_message_for(process_info, exit_status)
+          stderr = process_info[:stderr_output].to_s.strip
+          stdout = process_info[:output].to_s.strip
+          message = stderr.empty? ? stdout : stderr
+          return message unless message.empty?
+
+          "ace-test exited with status #{exit_status}"
+        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)
+          return nil unless summary_fresh_for_run?(summary_file, process_info[:start_time])
+
+          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,
+            skipped: json_data["skipped"] || 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 summary_fresh_for_run?(summary_file, start_time)
+          File.mtime(summary_file) >= (start_time - 0.001)
+        rescue StandardError
+          false
         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
@@ -46,6 +47,9 @@ module Ace
 
         def collect_results
           @packages.map do |package|
+            runtime = runtime_result(package)
+            next runtime if runtime_result_overrides_summary?(package, runtime)
+
             reports_dir = Atoms::ReportPathResolver.report_directory(
               package["path"],
               report_root: @report_root,
@@ -90,8 +94,7 @@ module Ace
                 }
               end
             else
-              # No summary file means tests didn't complete or save
-              {
+              runtime || {
                 package: package["name"],
                 path: package["path"],
                 report_root: @report_root,
@@ -106,6 +109,13 @@ module Ace
           end
         end
 
+        def runtime_result_overrides_summary?(package, runtime)
+          return false unless runtime
+
+          status = @runtime_results[package["name"]] || {}
+          status[:timed_out] || status[:interrupted] || runtime[:success] == false
+        end
+
         def collect_failed_packages(results)
           results.select { |r| !r[:success] }.map do |result|
             {
@@ -119,6 +129,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.25.5'
   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.25.5
 platform: ruby
 authors:
 - Michal Czyz
 bindir: exe
 cert_chain: []
-date: 1980-01-02 00:00:00.000000000 Z
+date: 2026-04-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ace-support-cli
@@ -189,9 +189,9 @@ files:
 - lib/ace/test_runner/formatters/progress_formatter.rb
 - lib/ace/test_runner/models/test_configuration.rb
 - lib/ace/test_runner/models/test_failure.rb
-- lib/ace/test_runner/models/test_group.rb
 - lib/ace/test_runner/models/test_report.rb
 - lib/ace/test_runner/models/test_result.rb
+- lib/ace/test_runner/models/test_target.rb
 - lib/ace/test_runner/molecules/cli_argument_parser.rb
 - lib/ace/test_runner/molecules/config_loader.rb
 - lib/ace/test_runner/molecules/deprecation_fixer.rb
@@ -206,7 +206,7 @@ files:
 - lib/ace/test_runner/molecules/test_executor.rb
 - lib/ace/test_runner/organisms/agent_reporter.rb
 - lib/ace/test_runner/organisms/report_generator.rb
-- lib/ace/test_runner/organisms/sequential_group_executor.rb
+- lib/ace/test_runner/organisms/sequential_target_executor.rb
 - lib/ace/test_runner/organisms/test_orchestrator.rb
 - lib/ace/test_runner/rake_task.rb
 - lib/ace/test_runner/suite.rb