ace-test-runner 0.27.1 → 0.28.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8b9e68c09f883cccd0d324be3b33f54de394293a8b0a4e7421ed697b8dffff7e
-  data.tar.gz: 92f8e49cccbf575821c3195bcdc92b7cf393c728474d7d116f77f3f94ad3fcae
+  metadata.gz: 8fc2c5132ba01f77ad703fc44426139e83ae2f930eb95a3ab26293f237bd13c7
+  data.tar.gz: b998e891eeecc4dd6ff6be3cdfcfb15c5d14a17333b306febecbd1db4dee4532
 SHA512:
-  metadata.gz: 0dd0f2a17a9bf8f99bc4fd6c3a7004d293a0f43a1838c0654bd98743e2277d734f42043cb2a56a3c7e0e994aa863c4ab3fac0771ae7709f28dadb7ed3ebd46fb
-  data.tar.gz: cca845831f57a5b706dd547560c351ea30d19e17b99d838a8f0e1f7fadb157fd14eb35aa08a60715a49d3a24e02193e638135c075ecbb79e52fa23e493a4a9ac
+  metadata.gz: d70486feda75375aaf8e5057adc1c6b9a10cf2692a7b2b7cd5d337c6375ba53a894c353de62b3178ca33e95460a208b367a9c283256b9ae8ee8127891f18e2bb
+  data.tar.gz: 2545709874b877010ad45bb538d05d03167b0a994a81119503a85c9f8666a13c689a2b971c738d8107d9f312785ec5a329de40718ac796baebb975f13f8421fa

data/.ace-defaults/test-runner/config.yml

@@ -26,6 +26,7 @@ patterns:
   core: "test/{fast/,}core/**/*_test.rb"
   lifecycle: "test/{fast/,}lifecycle/**/*_test.rb"
   edge: "test/{fast/,}edge/**/*_test.rb"
+  fast_tests: "test/fast/**/*_test.rb"
   feat_tests: "test/feat/**/*_test.rb"
 
 # Test targets that combine multiple patterns
@@ -45,6 +46,7 @@ targets:
     - contract
     - core
     - lifecycle
+    - fast_tests
   feat:
     - feat_tests
     - edge

data/CHANGELOG.md

@@ -7,6 +7,33 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.28.1] - 2026-10-08
+
+### Fixed
+
+- Reject missing explicit Ruby test files before loading tests or running selectors. Preserve exact unambiguous file-line selection.
+
+### Fixed
+
+- Refuse invalid or ambiguous file-line selections and execute exact class/method identities in direct and subprocess modes. Reject mixed whole-file/line selections before loading tests.
+
+- Include uncategorized fast test directories in default fast/all selection without executing overlapping matches twice or widening explicit target overrides.
+- Exclude undispatched groups from sequential execution reports after target fail-fast.
+
+## [0.28.0] - 2026-10-05
+
+### Fixed
+
+- Honor explicit `ace-test-suite --config FILE` without merging the default cascade, and refuse unreadable or malformed selected files. Default namespace discovery remains unchanged.
+
+- Bind suite verdicts, counts and report links to each exact child invocation; preserve duplicate entries and no-save completion evidence during concurrent runs.
+
+- Preserve unsuccessful execution through target aggregation and saved/CLI verdicts even after passing partial output; distinguish operator interruption from completed test errors.
+
+### Changed
+
+- Declare the required direct dependencies and minimum producer versions for this coordinated release: `ace-support-fs ~> 0.3`.
+
 ## [0.27.1] - 2026-09-29
 
 ### Fixed

data/exe/ace-test-suite

@@ -7,7 +7,7 @@ require "ace/test_runner"
 require "ace/test_runner/suite"
 
 options = {
-  config: ".ace/test/suite.yml",
+  config: nil,
   parallel: nil,
   group: nil,
   verbose: false,
@@ -87,11 +87,20 @@ rescue OptionParser::InvalidArgument => e
   exit 1
 end
 
-# Load the config using namespace method
-config = Ace::Core.get("test", file: "suite")
+# Explicit files replace the cascade; omitting --config keeps namespace discovery.
+begin
+  config = if options[:config]
+    Ace::Support::Config::Molecules::YamlLoader.load_file(options[:config]).data
+  else
+    Ace::Core.get("test", file: "suite")
+  end
+rescue Ace::Support::Config::Error, Psych::Exception => e
+  puts "Error: Configuration file #{options[:config] || '.ace/test/suite.yml'}: #{e.message}"
+  exit 1
+end
 
 unless config.is_a?(Hash) && config["test_suite"].is_a?(Hash)
-  puts "Error: Configuration file not found: .ace/test/suite.yml"
+  puts "Error: Invalid or missing test suite configuration: #{options[:config] || '.ace/test/suite.yml'}"
   puts
   puts "Create a test suite configuration at .ace/test/suite.yml in your project root"
   puts

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

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require_relative "line_number_resolver"
+require_relative "../molecules/selection_resolver"
+require "shellwords"
 
 module Ace
   module TestRunner
@@ -13,6 +15,8 @@ module Ace
         end
 
         def build_test_command(files, options = {})
+          selection = options[:selection_plan] || Molecules::SelectionResolver.resolve(Array(files))
+          return exact_selection_command(selection, options) if selection.qualified?
           cmd_parts = []
 
           # Use bundler if available and requested
@@ -29,39 +33,28 @@ module Ace
 
           # 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)
+            # 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("; ")}\""
           elsif options[:profile]
             # Single file without line number
             cmd_parts << "-e"
@@ -100,60 +93,41 @@ module Ace
 
         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
+        def exact_selection_command(plan, options)
+          argv = []
+          argv.concat(["bundle", "exec"]) if @bundler && bundler_available?
+          argv.concat(Shellwords.split(@ruby_command))
+          argv << "-Ilib:test" unless options[:no_load_path]
+          model = File.expand_path("../models/test_selection_plan", __dir__)
+          verifier = File.expand_path("../molecules/selection_verifier", __dir__)
+          script = <<~RUBY
+            begin
+              require #{model.inspect}
+              require #{verifier.inspect}
+              plan = Ace::TestRunner::Models::TestSelectionPlan.new(
+                files: #{plan.files.inspect}, identities: #{plan.identities.inspect},
+                source_digests: #{plan.source_digests.inspect})
+              verifier = Ace::TestRunner::Molecules::SelectionVerifier
+              verifier.verify_sources!(plan)
+              require "minitest/autorun"
+              plan.files.each { |file| require file }
+              pattern = verifier.verify_loaded!(plan)
+              args = ["--name", "/" + pattern + "/"]
+              args << "--verbose" if #{!!options[:profile]}
+              Minitest::Reporters.use! Minitest::Reporters::DefaultReporter.new
+              success = verifier.verify_execution!(plan) { Minitest.run(args) }
+              STDOUT.flush
+              STDERR.flush
+              exit!(success ? 0 : 1)
+            rescue Exception => error
+              STDERR.puts(error.message)
+              STDERR.flush
+              exit!(1)
             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("; ")}\""
+          RUBY
+          argv.concat(["-e", script])
+          argv.concat(Array(options[:args])) if options[:args]
+          argv
         end
 
         def bundler_available?

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

@@ -1,85 +1,92 @@
 # frozen_string_literal: true
 
+require "prism"
+
 module Ace
   module TestRunner
     module Atoms
-      # Resolves line numbers to test method names
       module LineNumberResolver
+        class SelectionError < ArgumentError; end
         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)
+        def parse_file_with_line(selector)
+          if (match = /\A(.+\.rb):(.+)\z/.match(selector))
+            unless match[2].match?(/\A[1-9]\d*\z/)
+              raise SelectionError, "Invalid test selector: #{selector}"
+            end
+            {file: match[1], line: Integer(match[2], 10)}
+          else
+            {file: selector, line: nil}
+          end
         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
+        def resolve_test_at_line(file_path, line_number)
+          resolve_identity(file_path, line_number).fetch(:name)
+        end
 
-              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
+        def resolve_identity(file_path, line_number, source: nil)
+          selector = "#{file_path}:#{line_number}"
+          source ||= File.read(file_path)
+          unless line_number.is_a?(Integer) && line_number.positive? && line_number <= source.lines.size
+            raise SelectionError, "Invalid test selector: #{selector}"
           end
+          parsed = Prism.parse(source)
+          raise SelectionError, "Malformed Ruby in test selector: #{selector}" unless parsed.success?
 
-          # Close last test if still open
-          if current_test
-            current_test[:end_line] = lines.size
-            test_methods << current_test
-          end
+          declarations = []
+          scopes = Hash.new(0)
+          collect(parsed.value, [], false, true, declarations, scopes)
+          matches = declarations.select { |entry| (entry[:start_line]..entry[:end_line]).cover?(line_number) }
+          selected = matches.one? && matches.first
+          valid = selected && selected[:supported] && scopes[selected[:class_name]] == 1 &&
+            declarations.count { |entry| entry.values_at(:class_name, :name) == selected.values_at(:class_name, :name) } == 1
+          raise SelectionError, "Unmatched or ambiguous test selector: #{selector}" unless valid
 
-          test_methods
+          selected.reject { |key, _| key == :supported }.merge(file: File.expand_path(file_path)).freeze
+        rescue Errno::ENOENT, Errno::EACCES, Errno::EISDIR => error
+          raise SelectionError, "Cannot read test selector #{selector}: #{error.class}"
         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}
+        def collect(node, namespace, in_class, supported, declarations, scopes)
+          return unless node
+          case node
+          when Prism::ProgramNode
+            collect(node.statements, namespace, in_class, supported, declarations, scopes)
+          when Prism::StatementsNode
+            node.body.each { |child| collect(child, namespace, in_class, supported, declarations, scopes) }
+          when Prism::ClassNode, Prism::ModuleNode
+            text = node.constant_path.location.slice
+            static = text.match?(/\A(?:::)?[A-Z]\w*(?:::[A-Z]\w*)*\z/)
+            parts = static ? text.delete_prefix("::").split("::") : []
+            path = text.start_with?("::") ? parts : namespace + parts
+            scopes[path.join("::")] += 1
+            collect(node.body, path, node.is_a?(Prism::ClassNode), supported && static, declarations, scopes)
+          when Prism::DefNode
+            if node.name.to_s.start_with?("test_")
+              add_declaration(node, node.name.to_s, namespace, supported && in_class && node.receiver.nil?,
+                node.def_keyword_loc.start_line, declarations)
+            end
+            # Nested declarations cannot acquire the surrounding static class's identity.
+            collect(node.body, namespace, in_class, false, declarations, scopes)
+          when Prism::CallNode
+            if node.name == :test && node.block.is_a?(Prism::BlockNode)
+              arguments = node.arguments&.arguments || []
+              literal = arguments.one? && arguments.first.is_a?(Prism::StringNode)
+              name = literal ? "test_#{arguments.first.unescaped.gsub(/\s+/, '_')}" : nil
+              static = supported && in_class && node.receiver.nil? && literal && node.block.opening_loc.slice == "do"
+              add_declaration(node, name, namespace, static, node.block.opening_loc.start_line, declarations)
+            end
+            node.compact_child_nodes.each { |child| collect(child, namespace, in_class, false, declarations, scopes) }
           else
-            {file: file_with_line, line: nil}
+            node.compact_child_nodes.each { |child| collect(child, namespace, in_class, false, declarations, scopes) }
           end
         end
+
+        def add_declaration(node, name, namespace, supported, method_line, declarations)
+          declarations << {name: name, class_name: namespace.join("::"), start_line: node.location.start_line,
+            end_line: node.location.end_line, method_line: method_line, supported: supported}
+        end
+        private_class_method :collect, :add_declaration
       end
     end
   end

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

@@ -15,7 +15,7 @@ module Ace
           # Pattern for inline errors - same structure as failures but with ERROR marker
           inline_error: /^\s+(test_[\w_]+).*?ERROR.*?\([\d.]+s\)\n(.*?)(?=^\s+test_[\w_]+.*?(?:PASS|FAIL|ERROR|SKIP)|^Finished in|\z)/m,
           location: /\[(.*?):(\d+)\]/,
-          duration: /Finished in ([\d.]+)s/,
+          duration: /Finished(?: tests)? in ([\d.]+)s/,
           deprecation: /DEPRECATION WARNING: (.+)/,
           # Pattern to capture individual test times from verbose output
           # Matches Minitest::Reporters DefaultReporter format:

data/lib/ace/test_runner/cli/commands/test.rb

@@ -90,6 +90,7 @@ module Ace
           # Execution mode options
           option :parallel, type: :boolean, desc: "Run tests in parallel (experimental)"
           option :per_file, type: :boolean, desc: "Execute each test file separately (slower, for debugging)"
+          # File-line selectors resolve exact declarations; mixed whole-file/line input refuses.
           option :direct, type: :boolean, desc: "Force in-process execution (faster, less isolation)"
           option :subprocess, type: :boolean, desc: "Force subprocess execution (slower, full isolation)"
           option :run_in_sequence, type: :boolean, aliases: %w[--ris], desc: "Run test targets sequentially (default)"
@@ -221,10 +222,8 @@ module Ace
             config_data = config_loader.load(options[:config_path])
             config = config_loader.merge_with_options(config_data, options)
 
-            timestamp_generator = Atoms::TimestampGenerator.new
             storage = Molecules::ReportStorage.new(
-              base_dir: config[:defaults][:report_dir] || ".ace-local/test/reports",
-              timestamp_generator: timestamp_generator
+              base_dir: config[:defaults][:report_dir] || ".ace-local/test/reports"
             )
 
             keep = options[:cleanup_keep] || 10

data/lib/ace/test_runner/formatters/json_formatter.rb

@@ -53,7 +53,9 @@ module Ace
               assertions: result.assertions,
               duration: result.duration,
               pass_rate: result.pass_rate,
-              success: result.success?
+              success: result.success?,
+              execution_success: result.execution_success,
+              execution_error: result.execution_error
             },
             timing: {
               start_time: result.start_time&.iso8601,

data/lib/ace/test_runner/formatters/progress_file_formatter.rb

@@ -24,8 +24,8 @@ module Ace
           # Report directory - use actual report path if available
           if @report_path
             lines << "Details: #{@report_path}/"
-          elsif @configuration && @configuration[:save_reports]
-            lines << "Details: #{@configuration[:report_dir] || ".ace-local/test/reports"}/latest/"
+          else
+            lines << "No saved report"
           end
 
           # Compact single-line summary with emoji status
@@ -42,7 +42,9 @@ module Ace
           lines << summary
 
           # Add failure details if there are any
-          if result.has_failures?
+          lines << "Execution failed: #{result.execution_error}" unless result.execution_success
+
+          if result.failed > 0 || result.errors > 0
             lines << ""
             total_failures = result.failed + result.errors
 
@@ -51,8 +53,8 @@ module Ace
 
             # Show failure count header with reference to full report if needed
             if total_failures > @max_failures_to_display
-              report_path = @report_path || "#{@configuration[:report_dir] || ".ace-local/test/reports"}/latest"
-              lines << "FAILURES (#{failures_to_show.size}/#{total_failures}) → #{report_path}/failures.json:"
+              reference = @report_path ? "→ #{@report_path}/failures.json" : "(no saved report)"
+              lines << "FAILURES (#{failures_to_show.size}/#{total_failures}) #{reference}:"
             else
               lines << "FAILURES (#{total_failures}):"
             end
@@ -87,8 +89,9 @@ module Ace
             # If there are more failures than displayed
             if result.failures_detail.size > @max_failures_to_display
               remaining = result.failures_detail.size - @max_failures_to_display
-              report_path = @report_path || "#{@configuration[:report_dir] || ".ace-local/test/reports"}/latest"
-              lines << "  ... and #{remaining} more #{(remaining == 1) ? "failure" : "failures"}. See full report: #{report_path}/failures.json"
+              reference = @report_path ? "See full report: #{@report_path}/failures.json" : "No saved report"
+              noun = remaining == 1 ? "failure" : "failures"
+              lines << "  ... and #{remaining} more #{noun}. #{reference}"
             end
           end
 

data/lib/ace/test_runner/formatters/progress_formatter.rb

@@ -29,8 +29,8 @@ module Ace
           # Report directory - use actual report path if available
           if @report_path
             lines << "Details: #{@report_path}/"
-          elsif @configuration && @configuration[:save_reports]
-            lines << "Details: #{@configuration[:report_dir] || ".ace-local/test/reports"}/latest/"
+          else
+            lines << "No saved report"
           end
 
           # Compact single-line summary with emoji status
@@ -43,7 +43,9 @@ module Ace
           lines << summary
 
           # Add failure details if there are any
-          if result.has_failures?
+          lines << "Execution failed: #{result.execution_error}" unless result.execution_success
+
+          if result.failed > 0 || result.errors > 0
             lines << ""
             total_failures = result.failed + result.errors
 
@@ -64,8 +66,8 @@ module Ace
 
             # Show failure count header with reference to full report if needed
             if total_failures > @max_failures_to_display
-              report_path = @report_path || "#{@configuration[:report_dir] || ".ace-local/test/reports"}/latest"
-              lines << "#{label} (#{failures_to_show.size}/#{total_failures}) → #{report_path}/failures.json:"
+              reference = @report_path ? "→ #{@report_path}/failures.json" : "(no saved report)"
+              lines << "#{label} (#{failures_to_show.size}/#{total_failures}) #{reference}:"
             else
               lines << "#{label} (#{total_failures}):"
             end
@@ -100,8 +102,9 @@ module Ace
             # If there are more failures than displayed
             if result.failures_detail.size > @max_failures_to_display
               remaining = result.failures_detail.size - @max_failures_to_display
-              report_path = @report_path || "#{@configuration[:report_dir] || ".ace-local/test/reports"}/latest"
-              lines << "  ... and #{remaining} more #{(remaining == 1) ? "failure" : "failures"}. See full report: #{report_path}/failures.json"
+              reference = @report_path ? "See full report: #{@report_path}/failures.json" : "No saved report"
+              noun = remaining == 1 ? "failure" : "failures"
+              lines << "  ... and #{remaining} more #{noun}. #{reference}"
             end
           end
 

data/lib/ace/test_runner/models/test_report.rb

@@ -76,6 +76,7 @@ module Ace
           lines << ""
           lines << "**Generated:** #{timestamp.strftime("%Y-%m-%d %H:%M:%S")}"
           lines << "**Status:** #{success? ? "✅ Success" : "❌ Failed"}"
+          lines << "**Execution failure:** #{result.execution_error}" unless result.execution_success
           lines << ""
 
           lines << "## Summary"

data/lib/ace/test_runner/models/test_result.rb

@@ -7,7 +7,7 @@ module Ace
       class TestResult
         attr_accessor :passed, :failed, :skipped, :errors, :assertions,
           :duration, :start_time, :end_time, :failures_detail,
-          :deprecations, :raw_output, :stderr
+          :deprecations, :raw_output, :stderr, :execution_success
 
         def initialize(attributes = {})
           @passed = attributes[:passed] || 0
@@ -22,6 +22,7 @@ module Ace
           @deprecations = attributes[:deprecations] || []
           @raw_output = attributes[:raw_output] || ""
           @stderr = attributes[:stderr] || ""
+          @execution_success = attributes.fetch(:execution_success, true) == true
         end
 
         def total_tests
@@ -29,11 +30,16 @@ module Ace
         end
 
         def success?
-          failed == 0 && errors == 0
+          execution_success && failed == 0 && errors == 0
         end
 
         def has_failures?
-          failed > 0 || errors > 0
+          !success?
+        end
+
+        def execution_error
+          return nil if execution_success
+          stderr.to_s.strip.empty? ? "Test execution did not complete successfully" : stderr.to_s.strip
         end
 
         def has_skips?
@@ -55,6 +61,7 @@ module Ace
           parts << "❌ #{failed} failed" if failed > 0
           parts << "💥 #{errors} errors" if errors > 0
           parts << "⚠️ #{skipped} skipped" if skipped > 0
+          parts << "❌ execution failed" unless execution_success
 
           parts.empty? ? "No tests executed" : parts.join(", ")
         end
@@ -70,6 +77,8 @@ module Ace
             duration: duration,
             pass_rate: pass_rate,
             success: success?,
+            execution_success: execution_success,
+            execution_error: execution_error,
             start_time: start_time&.iso8601,
             end_time: end_time&.iso8601,
             failures: failures_detail.map(&:to_h),