ace-test-runner 0.27.1 → 0.28.1

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Ace
+  module TestRunner
+    module Models
+      class TestSelectionPlan
+        attr_reader :files, :identities, :source_digests
+
+        def initialize(files:, identities:, source_digests:)
+          @files = freeze_values(files)
+          @identities = freeze_values(identities)
+          @source_digests = freeze_values(source_digests)
+          freeze
+        end
+
+        def qualified?
+          !identities.empty?
+        end
+
+        def for_file(file)
+          path = File.expand_path(file.sub(/:\d+$/, ""))
+          self.class.new(files: [path],
+            identities: identities.select { |identity| identity.fetch(:file) == path },
+            source_digests: source_digests.select { |key, _| key == path })
+        end
+
+        private
+
+        def freeze_values(value)
+          case value
+          when Hash
+            value.to_h { |key, entry| [freeze_values(key), freeze_values(entry)] }.freeze
+          when Array
+            value.map { |entry| freeze_values(entry) }.freeze
+          when String
+            value.dup.freeze
+          else
+            value.freeze
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ace/test_runner/molecules/cli_argument_parser.rb

@@ -38,6 +38,8 @@ module Ace
         #
         # @return [Hash] Parsed options with :package_dir, :target, :files keys
         def parse
+          require_relative "../atoms/line_number_resolver"
+          @argv.each { |argument| Atoms::LineNumberResolver.parse_file_with_line(argument) }
           parse_first_argument
           parse_remaining_arguments
 
@@ -125,6 +127,8 @@ module Ace
               @test_files << arg
             elsif package_relative_ruby_file?(arg)
               @test_files << arg
+            elsif literal_ruby_file?(arg)
+              raise ArgumentError, "File not found: #{arg}"
             elsif known_target?(arg)
               @target = arg
             elsif @target.nil? && !File.exist?(arg)
@@ -210,7 +214,7 @@ module Ace
         # Check if an argument could be a package name (not a target, file, or file:line)
         def potential_package?(arg)
           !known_target?(arg) &&
-            !(arg.end_with?(".rb") && File.file?(arg)) &&
+            !literal_ruby_file?(arg) &&
             !file_with_line?(arg)
         end
 
@@ -236,6 +240,10 @@ module Ace
           @test_files << (@package_dir ? format_file_with_line(file_part, line_part) : arg)
         end
 
+        def literal_ruby_file?(arg)
+          arg.end_with?(".rb") && !arg.match?(/[\*?\[\]{}]/)
+        end
+
         def existing_ruby_file?(arg)
           File.exist?(arg) && arg.end_with?(".rb")
         end

data/lib/ace/test_runner/molecules/execution_evidence.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "json"
+require "fileutils"
+
+module Ace
+  module TestRunner
+    module Molecules
+      # The completion file is published last, after the optional report is complete.
+      # A suite reads this exact file once; latest is only a navigation convenience.
+      class ExecutionEvidence
+        CHANNEL = "ACE_TEST_EXECUTION"
+        COUNTS = %w[total passed failed errors skipped assertions].freeze
+        attr_reader :identity, :path, :package, :entry_id, :package_path
+
+        def initialize(package_path:, package: nil, entry_id: nil, identity: SecureRandom.uuid, path: nil)
+          @identity = identity
+          @package_path = File.realpath(package_path)
+          @package = package || File.basename(@package_path)
+          @entry_id = entry_id || identity
+          @path = path || File.join(@package_path, ".ace-local/test/completions", "#{identity}.json")
+        end
+
+        def self.for_invocation(package_path)
+          channel = ENV[CHANNEL]
+          return new(package_path: package_path) unless channel
+
+          data = JSON.parse(channel, symbolize_names: true)
+          raise Error, "Execution package path mismatch" unless File.realpath(package_path) == data[:package_path]
+
+          new(**data)
+        end
+
+        def channel
+          JSON.generate(identity: identity, path: path, package: package, entry_id: entry_id, package_path: package_path)
+        end
+
+        def publish(result, files:, report_dir: nil)
+          data = {
+            execution_id: identity, entry_id: entry_id, package: package, package_path: package_path,
+            pid: Process.pid, completed: true, selected_files: files, report_dir: report_dir,
+            total: result.total_tests, passed: result.passed, failed: result.failed, errors: result.errors,
+            skipped: result.skipped, assertions: result.assertions, duration: result.duration,
+            success: result.success?, error: result.execution_error
+          }
+          FileUtils.mkdir_p(File.dirname(path))
+          temporary = "#{path}.#{SecureRandom.uuid}.tmp"
+          File.write(temporary, JSON.generate(data))
+          # Exclusive publication: a completed invocation may never be replaced.
+          File.link(temporary, path)
+          data
+        ensure
+          FileUtils.rm_f(temporary) if temporary
+        end
+
+        def read(pid:, save_reports:)
+          data = JSON.parse(File.read(path))
+          valid = data.is_a?(Hash) && data["completed"] == true &&
+            data["execution_id"] == identity && data["entry_id"] == entry_id &&
+            data["package"] == package && data["package_path"] == package_path && data["pid"] == pid &&
+            data["selected_files"].is_a?(Array) && data["selected_files"].all? { |file| file.is_a?(String) } &&
+            COUNTS.all? { |key| data[key].is_a?(Integer) && data[key] >= 0 } &&
+            [true, false].include?(data["success"]) && data["duration"].is_a?(Numeric) &&
+            data["duration"].finite? && data["duration"] >= 0 &&
+            data["total"] == data.values_at("passed", "failed", "errors", "skipped").sum &&
+            (!data["success"] || data["failed"] + data["errors"] == 0) &&
+            (!data["selected_files"].empty? || data["total"] == 0) &&
+            (!data["success"] || data["total"] > 0 || data["selected_files"].empty?)
+          raise Error, "Invalid or mismatched execution completion evidence" unless valid
+
+          if save_reports
+            validate_report!(data)
+          elsif data["report_dir"]
+            raise Error, "Unexpected saved report in no-save execution"
+          end
+          data.transform_keys(&:to_sym)
+        rescue SystemCallError, JSON::ParserError, TypeError => e
+          raise Error, "Unverifiable execution completion evidence: #{e.message}"
+        end
+
+        private
+
+        def validate_report!(data)
+          directory = data["report_dir"]
+          raise Error, "Missing concrete execution report directory" unless directory.is_a?(String) &&
+            File.absolute_path(directory) == directory && File.basename(directory) == identity && !File.symlink?(directory)
+
+          summary = JSON.parse(File.read(File.join(directory, "summary.json")))
+          report = JSON.parse(File.read(File.join(directory, "report.json")))
+          raise Error, "Mismatched execution summary/report" unless summary.is_a?(Hash) && report.is_a?(Hash) &&
+            summary["execution_id"] == identity && report.dig("metadata", "execution_id") == identity &&
+            report["report_path"] == directory && report["files_tested"] == data["selected_files"] &&
+            report.dig("result", "total_tests") == data["total"] &&
+            COUNTS.all? { |key| summary[key] == data[key] } && summary["success"] == data["success"] &&
+            summary["duration"] == data["duration"] &&
+            %w[passed failed errors skipped assertions duration success].all? { |key| report.dig("result", key) == data[key] }
+        end
+      end
+    end
+  end
+end

data/lib/ace/test_runner/molecules/failed_package_reporter.rb

@@ -10,79 +10,18 @@ module Ace
         module_function
 
         def format_for_display(package)
-          path = extract_path(package)
-          report_root = extract_report_root(package)
-          package_name = extract_name(package) || File.basename(path)
-          report_path = Atoms::ReportPathResolver.call(
-            path,
-            report_root: report_root,
-            package_name: package_name
-          )
-
-          if report_path
-            begin
-              relative_path = Pathname.new(report_path).relative_path_from(Dir.pwd)
-              "    → See #{relative_path}"
-            rescue => e
-              warn "Failed to calculate relative path: #{e.message}" if debug_mode?
-              "    → See #{report_path}"
-            end
-          else
-            reports_path = fallback_reports_path(path, report_root, package_name)
-            begin
-              relative_path = Pathname.new(reports_path).relative_path_from(Dir.pwd)
-              "    → Check #{relative_path}/ for details"
-            rescue => e
-              warn "Failed to calculate relative path: #{e.message}" if debug_mode?
-              "    → Check #{reports_path}/ for details"
-            end
-          end
+          directory = package[:report_dir] || package["report_dir"]
+          directory ? "    → See #{relative_or_absolute(directory)}" : "    → No saved report"
         end
 
         def format_for_markdown(package)
-          path = extract_path(package)
-          report_root = extract_report_root(package)
-          package_name = extract_name(package) || File.basename(path)
-          report_path = Atoms::ReportPathResolver.call(
-            path,
-            report_root: report_root,
-            package_name: package_name
-          )
-
-          if report_path
-            relative_report_path = relative_or_absolute(report_path)
-            "- Report: `#{relative_report_path}`"
-          else
-            reports_path = fallback_reports_path(path, report_root, package_name)
-            relative_reports_path = relative_or_absolute(reports_path)
-            "- Report: Check `#{relative_reports_path}/` for details"
-          end
+          directory = package[:report_dir] || package["report_dir"]
+          directory ? "- Report: `#{relative_or_absolute(directory)}`" : "- No saved report"
         end
 
         class << self
           private
 
-          def extract_path(package)
-            package[:path] || package["path"]
-          end
-
-          def extract_name(package)
-            package[:name] || package["name"]
-          end
-
-          def extract_report_root(package)
-            package[:report_root] || package["report_root"]
-          end
-
-          def fallback_reports_path(path, report_root, package_name)
-            if report_root
-              short_name = package_name.to_s.sub(/\Aace-/, "")
-              return File.join(report_root, short_name) unless short_name.empty?
-            end
-
-            File.join(path, "test-reports")
-          end
-
           def debug_mode?
             ENV["DEBUG"]
           end

data/lib/ace/test_runner/molecules/in_process_runner.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "stringio"
+require "timeout"
 require "ostruct"
 require "minitest"
 
@@ -10,6 +11,16 @@ module Ace
       # Runs tests directly in the current Ruby process without spawning subprocesses
       # This provides significantly faster execution for unit tests that don't need isolation
       class InProcessRunner
+        # Minitest converts ordinary timeout exceptions into completed test
+        # errors. Its pass-through SystemExit boundary preserves execution
+        # deadlines; this owner catches the private control-flow exception.
+        class ExecutionTimeout < SystemExit
+          def initialize(*)
+            super(124)
+          end
+        end
+        private_constant :ExecutionTimeout
+
         def initialize(timeout: nil, launch_env:)
           @timeout = timeout
           @launch_env = launch_env  # Hermetic fixture environment applied for the test run
@@ -52,30 +63,11 @@ module Ace
               require "minitest/autorun"
             end
 
-            # First pass: check for line numbers and resolve test names
-            # This must be done before loading files
-            test_names_to_run = []
-            files_to_load = []
-
-            files.each do |file|
-              # Check if file has line number (file:line format)
-              if file =~ /^(.+):(\d+)$/
-                actual_file = $1
-                line_number = $2.to_i
-
-                # Resolve line number to test name
-                require_relative "../atoms/line_number_resolver"
-                test_name = Ace::TestRunner::Atoms::LineNumberResolver.resolve_test_at_line(actual_file, line_number)
-                test_names_to_run << test_name if test_name
-
-                files_to_load << actual_file
-              else
-                files_to_load << file
-              end
-            end
-
-            # Store test names in options to pass to run_minitest_with_args
-            options = options.merge(test_names_filter: test_names_to_run) if test_names_to_run.any?
+            require_relative "selection_resolver"
+            require_relative "selection_verifier"
+            selection = options[:selection_plan] || SelectionResolver.resolve(files)
+            SelectionVerifier.verify_sources!(selection)
+            files_to_load = selection.files
 
             # Clear previously loaded test classes to avoid accumulation between groups
             # This is crucial for in-process execution where tests from previous groups
@@ -118,18 +110,27 @@ module Ace
               end
             end
 
+            if selection.qualified?
+              options = options.merge(selection_pattern: SelectionVerifier.verify_loaded!(selection))
+            end
+
             # Run Minitest with captured output
             # Suppress Minitest's own output by using null reporter
-            exit_code = if @timeout
-              Timeout.timeout(@timeout) do
+            execution = lambda do
+              if @timeout
+                Timeout.timeout(@timeout, ExecutionTimeout) { run_minitest_silent(options) }
+              else
                 run_minitest_silent(options)
               end
+            end
+            exit_code = if selection.qualified?
+              SelectionVerifier.verify_execution!(selection, &execution)
             else
-              run_minitest_silent(options)
+              execution.call
             end
 
             success = exit_code == true || exit_code == 0
-          rescue Timeout::Error
+          rescue ExecutionTimeout, Timeout::Error
             stderr_io.puts "Test execution timed out after #{@timeout} seconds"
             success = false
             exit_code = 124
@@ -232,9 +233,8 @@ module Ace
           args << "--verbose" if options[:verbose]
 
           # Add test name filter if line numbers were provided
-          if options[:test_names_filter] && options[:test_names_filter].any?
-            pattern = options[:test_names_filter].map { |name| Regexp.escape(name) }.join("|")
-            args << "--name" << "/#{pattern}/"
+          if options[:selection_pattern]
+            args << "--name" << "/#{options[:selection_pattern]}/"
           end
 
           # Run Minitest
@@ -251,14 +251,25 @@ module Ace
           args << "--seed" << options[:seed].to_s if options[:seed]
 
           # Add test name filter if line numbers were provided
-          if options[:test_names_filter] && options[:test_names_filter].any?
-            pattern = options[:test_names_filter].map { |name| Regexp.escape(name) }.join("|")
-            args << "--name" << "/#{pattern}/"
+          if options[:selection_pattern]
+            args << "--name" << "/#{options[:selection_pattern]}/"
           end
 
-          # Reporter already set up before loading test files
-          # Run Minitest
-          Minitest.run(args)
+          # Minitest swallows Interrupt and returns a normal failure. Preserve
+          # operator SIGINT as interruption so the owner never writes a completed
+          # report for this invocation.
+          interrupted = false
+          previous_handler = Signal.trap("INT") do
+            interrupted = true
+            raise Interrupt
+          end
+          begin
+            result = Minitest.run(args)
+            raise Interrupt if interrupted
+            result
+          ensure
+            Signal.trap("INT", previous_handler)
+          end
         end
       end
     end

data/lib/ace/test_runner/molecules/pattern_resolver.rb

@@ -5,7 +5,8 @@ module Ace
     module Molecules
       class PatternResolver
         INTERNAL_PATTERN_LABELS = {
-          "feat_tests" => "feat"
+          "feat_tests" => "feat",
+          "fast_tests" => "fast"
         }.freeze
 
         attr_reader :using_catch_all
@@ -42,7 +43,7 @@ module Ace
           targets.flat_map { |target| resolve_target(target) }.uniq
         end
 
-        def resolve_target_sequential(target_name, seen = [])
+        def resolve_target_sequential(target_name, seen = [], selected = {})
           target_key = target_name.to_s
           if seen.include?(target_key)
             raise ArgumentError, "Cyclic test target definition detected: #{(seen + [target_key]).join(' -> ')}"
@@ -55,12 +56,14 @@ module Ace
             member_key = member.to_s
 
             if @targets.key?(member_key)
-              resolve_target_sequential(member_key, seen + [target_key])
+              resolve_target_sequential(member_key, seen + [target_key], selected)
             elsif @patterns.key?(member_key)
-              files = expand_pattern(@patterns[member_key])
+              files = expand_pattern(@patterns[member_key]).reject { |file| selected.key?(file) }
+              files.each { |file| selected[file] = true }
               files.empty? ? [] : [{name: display_name_for(member_key), files: files}]
             else
-              files = expand_pattern(member)
+              files = expand_pattern(member).reject { |file| selected.key?(file) }
+              files.each { |file| selected[file] = true }
               files.empty? ? [] : [{name: "other", files: files}]
             end
           end

data/lib/ace/test_runner/molecules/report_storage.rb

@@ -1,22 +1,33 @@
 # frozen_string_literal: true
 
+require "securerandom"
+
 module Ace
   module TestRunner
     module Molecules
       # Handles storage of test reports to filesystem
       class ReportStorage
-        def initialize(base_dir: ".ace-local/test/reports", timestamp_generator: nil)
+        def initialize(base_dir: ".ace-local/test/reports")
           @base_dir = base_dir
-          @timestamp_generator = timestamp_generator || Atoms::TimestampGenerator.new
         end
 
-        def save_report(report, format: :json)
+        def reserve(execution_id = SecureRandom.uuid)
+          ensure_base_directory
+          directory = File.join(File.expand_path(@base_dir), execution_id)
+          Dir.mkdir(directory)
+          directory
+        end
+
+        def save_report(report, format: :json, report_dir: nil)
           ensure_base_directory
-          report_dir = create_report_directory
+          report_dir ||= reserve
+          report.report_path = report_dir
+          report.metadata[:execution_id] = File.basename(report_dir)
 
           case format
           when :json
             save_json_report(report, report_dir)
+            save_summary(report.result, report_dir)
           when :markdown
             save_markdown_report(report, report_dir)
           when :all
@@ -50,6 +61,8 @@ module Ace
           summary_file = File.join(report_dir, "summary.json")
 
           summary_data = {
+            execution_id: File.basename(report_dir),
+            assertions: result.assertions,
             passed: result.passed,
             failed: result.failed,
             errors: result.errors,
@@ -61,7 +74,7 @@ module Ace
             timestamp: Time.now.iso8601
           }
 
-          File.write(summary_file, JSON.pretty_generate(summary_data))
+          File.open(summary_file, "wx") { |file| file.write(JSON.pretty_generate(summary_data)) }
           summary_file
         end
 
@@ -211,27 +224,18 @@ module Ace
           FileUtils.mkdir_p(dir) unless Dir.exist?(dir)
         end
 
-        def create_report_directory
-          ensure_base_directory
-          timestamp = @timestamp_generator.directory_name
-          report_dir = File.join(@base_dir, timestamp)
-          FileUtils.mkdir_p(report_dir)
-          report_dir
-        end
-
         def create_latest_symlink(report_dir)
           latest_link = File.join(@base_dir, "latest")
-
-          # Remove existing symlink if present
-          FileUtils.rm_f(latest_link) if File.exist?(latest_link)
-
-          # Create new symlink to the latest report
-          FileUtils.ln_s(File.basename(report_dir), latest_link)
+          temporary = "#{latest_link}.#{SecureRandom.uuid}"
+          File.symlink(File.basename(report_dir), temporary)
+          File.rename(temporary, latest_link)
+        ensure
+          FileUtils.rm_f(temporary) if temporary
         end
 
         def save_json_report(report, report_dir)
           report_file = File.join(report_dir, "report.json")
-          File.write(report_file, report.to_json)
+          File.open(report_file, "wx") { |file| file.write(report.to_json) }
           report_file
         end
 

data/lib/ace/test_runner/molecules/selection_resolver.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require "digest"
+require_relative "../atoms/line_number_resolver"
+require_relative "../models/test_selection_plan"
+
+module Ace
+  module TestRunner
+    module Molecules
+      module SelectionResolver
+        module_function
+
+        def resolve(files)
+          parsed = Array(files).map { |selector| Atoms::LineNumberResolver.parse_file_with_line(selector) }
+          qualified = parsed.count { |entry| entry[:line] }
+          if qualified.positive? && qualified != parsed.size
+            raise Atoms::LineNumberResolver::SelectionError,
+              "Mixed whole-file and file:line selectors are unsupported: #{files.join(', ')}"
+          end
+          if qualified.zero?
+            return Models::TestSelectionPlan.new(files: Array(files), identities: [], source_digests: {})
+          end
+
+          sources = {}
+          identities = parsed.map do |entry|
+            path = File.expand_path(entry.fetch(:file))
+            source = sources[path] ||= File.read(path)
+            Atoms::LineNumberResolver.resolve_identity(path, entry.fetch(:line), source: source)
+          rescue SystemCallError => error
+            raise Atoms::LineNumberResolver::SelectionError,
+              "Cannot read test selector #{entry[:file]}:#{entry[:line]}: #{error.class}"
+          end
+          identities = identities.uniq { |entry| entry.values_at(:file, :class_name, :name) }
+          identities.group_by { |entry| entry.values_at(:class_name, :name) }.each_value do |matches|
+            next if matches.size == 1
+            selectors = matches.map { |entry| "#{entry[:file]}:#{entry[:start_line]}" }.join(", ")
+            raise Atoms::LineNumberResolver::SelectionError, "Ambiguous test identity across files: #{selectors}"
+          end
+          Models::TestSelectionPlan.new(files: sources.keys, identities: identities,
+            source_digests: sources.transform_values { |source| Digest::SHA256.hexdigest(source) })
+        end
+      end
+    end
+  end
+end

data/lib/ace/test_runner/molecules/selection_verifier.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+require "digest"
+require "minitest/reporters"
+require_relative "../atoms/line_number_resolver"
+
+module Ace
+  module TestRunner
+    module Molecules
+      module SelectionVerifier
+        class ExecutionCollector < Minitest::Reporters::BaseReporter
+          attr_reader :identities
+
+          def initialize
+            super
+            @identities = []
+            @mutex = Mutex.new
+          end
+
+          def record(result)
+            @mutex.synchronize do
+              super
+              @identities << [result.class_name, result.name]
+            end
+          end
+        end
+
+        module_function
+
+        def verify_execution!(plan)
+          previous = Minitest::Reporters.reporters
+          collector = ExecutionCollector.new
+          Minitest::Reporters.reporters = Array(previous) + [collector]
+          result = yield
+          expected = plan.identities.map { |identity| identity.values_at(:class_name, :name) }.sort
+          unless collector.identities.sort == expected
+            raise Atoms::LineNumberResolver::SelectionError,
+              "Executed test identities do not match selected identities"
+          end
+          result
+        ensure
+          Minitest::Reporters.reporters = previous
+        end
+
+        def verify_sources!(plan)
+          plan.source_digests.each do |file, digest|
+            unless Digest::SHA256.file(file).hexdigest == digest
+              raise Atoms::LineNumberResolver::SelectionError, "Selected test source changed: #{file}"
+            end
+          end
+        end
+
+        def verify_loaded!(plan, runnables: Minitest::Runnable.runnables)
+          verify_sources!(plan)
+          # Minitest's default randomized enumeration requires a seed even before run.
+          Minitest.seed ||= Random.new_seed
+          plan.identities.each do |identity|
+            matches = runnables.select { |klass| klass.name == identity.fetch(:class_name) }
+            klass = matches.first
+            valid = matches.size == 1 && klass < Minitest::Test && klass.public_instance_methods.include?(identity.fetch(:name).to_sym)
+            valid &&= klass.runnable_methods.count(identity.fetch(:name)) == 1
+            if valid
+              method = klass.instance_method(identity.fetch(:name))
+              source = method.source_location
+              valid = method.owner == klass && source &&
+                File.expand_path(source.first) == identity.fetch(:file) && source.last == identity.fetch(:method_line)
+            end
+            unless valid
+              raise Atoms::LineNumberResolver::SelectionError,
+                "Selected test identity does not match loaded runnable: #{identity[:class_name]}##{identity[:name]}"
+            end
+          end
+          names = plan.identities.map { |identity| Regexp.escape("#{identity[:class_name]}##{identity[:name]}") }
+          "\\A(?:#{names.join('|')})\\z"
+        end
+      end
+    end
+  end
+end