henitai 0.5.1 → 0.6.0

data/lib/henitai/git_diff_analyzer.rb

@@ -9,14 +9,23 @@ module Henitai
   # Shells out to git to discover changed files between two refs.
   #
   # By default the analyzer runs in the current working directory. Callers can
-  # pass dir: to point it at another repository root without changing cwd.
+  # pass dir: to point it at another directory without changing cwd.
+  #
+  # Every path is reported relative to that directory, which need not be the
+  # repository root: `git diff` would otherwise print root-relative paths
+  # while `git ls-files` prints directory-relative ones. Paths are read
+  # NUL-separated so git never quotes non-ASCII names.
   class GitDiffAnalyzer
-    def changed_files(from:, to:, dir: Dir.pwd)
-      stdout, stderr, status = git_diff(dir, "--name-only", from, to)
+    NAME_ONLY = ["--name-only", "--relative", "-z"].freeze
 
-      raise GitDiffError, stderr.strip unless status.success?
+    def changed_files(from:, to:, dir: Dir.pwd)
+      diff_paths(dir, from, to)
+    end
 
-      stdout.split("\n").reject(&:empty?)
+    # Changes on HEAD since its merge base with ref. Commits that landed on
+    # ref after the fork point are not part of this diff.
+    def changed_files_since(ref, dir: Dir.pwd)
+      diff_paths(dir, "#{ref}...HEAD")
     end
 
     def working_tree_changed_files(dir: Dir.pwd)
@@ -55,7 +64,7 @@ module Henitai
     end
 
     def changed_line_ranges(path, from:, to:, dir:)
-      stdout, stderr, status = git_diff(dir, "--unified=0", from, to, "--", path)
+      stdout, stderr, status = git_diff(dir, "--unified=0", "--relative", from, to, "--", path)
 
       raise GitDiffError, stderr.strip unless status.success?
 
@@ -94,23 +103,31 @@ module Henitai
       Open3.capture3(*command)
     end
 
-    def working_tree_tracked_files(dir)
-      stdout, stderr, status = git_diff(dir, "--name-only", "HEAD")
+    def diff_paths(dir, *revisions)
+      stdout, stderr, status = git_diff(dir, *NAME_ONLY, *revisions)
 
       raise GitDiffError, stderr.strip unless status.success?
 
-      stdout.split("\n").reject(&:empty?)
+      paths(stdout)
+    end
+
+    def working_tree_tracked_files(dir)
+      diff_paths(dir, "HEAD")
     end
 
     def untracked_files(dir)
       command = ["git"]
       command += ["-C", dir] if dir
-      command += ["ls-files", "--others", "--exclude-standard"]
+      command += ["ls-files", "--others", "--exclude-standard", "-z"]
       stdout, stderr, status = Open3.capture3(*command)
 
       raise GitDiffError, stderr.strip unless status.success?
 
-      stdout.split("\n").reject(&:empty?)
+      paths(stdout)
+    end
+
+    def paths(stdout)
+      stdout.dup.force_encoding(Encoding::UTF_8).split("\0").reject(&:empty?)
     end
   end
 end

data/lib/henitai/incremental_filter.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require_relative "signature_line"
 require_relative "verdict_fingerprint"
 
 module Henitai
@@ -8,23 +9,26 @@ module Henitai
   #
   # Reuse rules (conservative — any doubt resolves to re-execution):
   #
+  #   * Both verdicts: the stored {ReuseContext} fingerprint (test
+  #     dependencies, verdict-relevant configuration, henitai version) must
+  #     equal the current one. Rows recorded without a context are never
+  #     reused.
   #   * Killed: the stored verdict must carry both fingerprints, and both the
   #     subject's source and every recorded covering test file must be
   #     byte-identical to what was recorded. Killed is monotone, so no live
   #     coverage is needed.
   #   * Survived: additionally the LIVE covering set (the full-map
   #     intersection computed via {PerTestCoverage}) must equal the recorded
-  #     set in membership, and the run-level dependency fingerprint must be
-  #     unchanged — a new or edited test reaching the mutant always forces a
-  #     re-run (ADR-11). Without a live per-test map or dependency
-  #     fingerprint, survivors always re-execute.
+  #     set in membership — a new or edited test reaching the mutant always
+  #     forces a re-run (ADR-11). Without a live per-test map or a context,
+  #     survivors always re-execute.
   #
   # Timeouts, errors, unknown ids and legacy rows always re-execute.
   class IncrementalFilter
-    def initialize(history_store:, per_test_coverage: nil, dependency_fingerprint: nil)
+    def initialize(history_store:, per_test_coverage: nil, reuse_context: nil)
       @history_store = history_store
       @per_test_coverage = per_test_coverage
-      @dependency_fingerprint = dependency_fingerprint
+      @reuse_context = reuse_context
     end
 
     # @return [Array<Mutant>] the same collection; cache hits get the stored
@@ -48,7 +52,7 @@ module Henitai
 
     private
 
-    attr_reader :history_store, :per_test_coverage, :dependency_fingerprint
+    attr_reader :history_store, :per_test_coverage, :reuse_context
 
     # MutantIdentity deliberately omits source coordinates (line-drift
     # tolerance), so distinct mutants inside one subject can share a stable
@@ -75,7 +79,9 @@ module Henitai
 
     def killed_reusable?(mutant, verdict)
       subject_source_unchanged?(mutant, verdict) &&
-        VerdictFingerprint.tests_fingerprint_current?(verdict.fetch(:covered_tests_fingerprint))
+        VerdictFingerprint.tests_fingerprint_current?(
+          verdict.fetch(:covered_tests_fingerprint), context_sha: context_sha
+        )
     end
 
     # The filter checks per-test map availability itself instead of trusting
@@ -84,17 +90,21 @@ module Henitai
     # unknowable means re-execute.
     def survived_reusable?(mutant, verdict)
       return false unless per_test_coverage&.available?
+      return false if SignatureLine.on?(mutant)
       return false unless subject_source_unchanged?(mutant, verdict)
 
       VerdictFingerprint.survivor_fingerprint_current?(
         verdict.fetch(:covered_tests_fingerprint),
         live_paths: per_test_coverage.tests_covering(mutant),
-        dependency_sha: dependency_fingerprint
+        context_sha: context_sha
       )
     end
 
+    def context_sha = reuse_context&.fingerprint
+
     def subject_source_unchanged?(mutant, verdict)
-      VerdictFingerprint.subject_source_hash(mutant) == verdict.fetch(:subject_source_hash)
+      current = VerdictFingerprint.subject_source_hash(mutant)
+      !current.nil? && current == verdict.fetch(:subject_source_hash)
     end
   end
 end

data/lib/henitai/integration/base.rb

@@ -15,6 +15,9 @@ module Henitai
     class Base
       include ChildRuntimeControl
 
+      EXITED_GROUP_POLL_INTERVAL = 0.05
+      EXITED_GROUP_POLL_COUNT = 40
+
       # Child-run diagnostics. Public so the child-side modules mixed into
       # concrete adapters can reach it without `send`.
       def child_debug_log
@@ -57,6 +60,20 @@ module Henitai
         false
       end
 
+      # True when the integration can boot once in a fork server (ADR-15) and
+      # run mutants from the booted state.
+      def fork_server_supported?
+        false
+      end
+
+      # Loads the test environment and the given test files without running
+      # anything; only called inside the fork server process.
+      #
+      # @param test_files [Array<String>]
+      def preload_environment(test_files)
+        raise NotImplementedError
+      end
+
       def wait_with_timeout(pid, timeout)
         wakeup = Henitai.const_get(:ProcessWakeup).new.install
         return Process.last_status if wait_nonblocking(pid)
@@ -78,6 +95,29 @@ module Henitai
       end
 
       def cleanup_process_group(pid)
+        if leader_exited?(pid)
+          terminate_exited_group(pid)
+        else
+          terminate_running_group(pid)
+        end
+      rescue Errno::EPERM
+        cleanup_child_process(pid)
+      rescue Errno::ESRCH
+        nil
+      end
+
+      private
+
+      # A leader that already exited normally cannot be waited on again, so
+      # the group is polled for members instead of burning the grace period.
+      def terminate_exited_group(pid)
+        Process.kill(:SIGTERM, -pid)
+        return unless group_members_remain?(pid)
+
+        Process.kill(:SIGKILL, -pid)
+      end
+
+      def terminate_running_group(pid)
         grace_period = 2.0
         wakeup = Henitai.const_get(:ProcessWakeup).new.install
         Process.kill(:SIGTERM, -pid)
@@ -88,15 +128,34 @@ module Henitai
         return if wait_nonblocking(pid)
 
         Process.kill(:SIGKILL, -pid)
-      rescue Errno::EPERM
-        cleanup_child_process(pid)
-      rescue Errno::ESRCH
-        nil
       ensure
         wakeup&.close
       end
 
-      private
+      def leader_exited?(pid)
+        !Process.wait(pid, Process::WNOHANG).nil?
+      rescue Errno::ECHILD, Errno::ESRCH
+        true
+      end
+
+      def group_members_remain?(pid)
+        EXITED_GROUP_POLL_COUNT.times do
+          return false unless group_alive?(pid)
+
+          pause(EXITED_GROUP_POLL_INTERVAL)
+        end
+        group_alive?(pid)
+      end
+
+      # Signal 0 probes existence only: ESRCH means the group is empty.
+      def group_alive?(pid)
+        Process.kill(0, -pid)
+        true
+      rescue Errno::ESRCH
+        false
+      rescue Errno::EPERM
+        true
+      end
 
       def pause(seconds)
         sleep(seconds)
@@ -133,6 +192,10 @@ module Henitai
         { "PARALLEL_WORKERS" => "1" }
       end
 
+      def suite_process_env
+        subprocess_env.merge(SuiteBootClock::STARTED_AT_ENV => Time.now.to_f.to_s)
+      end
+
       def wait_nonblocking(pid)
         Process.wait(pid, Process::WNOHANG)
       rescue Errno::ECHILD, Errno::ESRCH
@@ -143,6 +206,10 @@ module Henitai
         @scenario_log_support ||= ScenarioLogSupport.new
       end
 
+      def child_report_store
+        @child_report_store ||= ChildReportStore.new
+      end
+
       def with_subprocess_env
         original_env = {} # : Hash[String, String?]
         subprocess_env.each do |key, value|

data/lib/henitai/integration/capped_log_sink.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Henitai
+  module Integration
+    # Writes captured child output to a log file up to a byte cap, then
+    # discards the overflow and leaves a single truncation marker behind.
+    # Not interrupt-safe: the drain thread must be stopped cooperatively,
+    # never killed mid-write.
+    class CappedLogSink
+      def initialize(file, cap)
+        @file = file
+        @cap = cap
+        @written = 0
+        @truncated = false
+      end
+
+      def write(chunk)
+        return unless @written < @cap
+
+        slice = chunk.byteslice(0, @cap - @written)
+        @file.write(slice)
+        @written += slice.bytesize
+        write_truncation_marker if @written >= @cap && !@truncated
+      end
+
+      private
+
+      def write_truncation_marker
+        @file.write("\n[henitai] output truncated at #{@cap} bytes\n")
+        @truncated = true
+      end
+    end
+  end
+end

data/lib/henitai/integration/child_bootstrap.rb

@@ -9,6 +9,12 @@ module Henitai
     # without forking, and so both the RSpec and Minitest paths -- which share
     # MutantRunSupport#spawn_mutant -- get identical treatment.
     module ChildBootstrap
+      # Signals the parent traps for its own shutdown (INT/TERM/HUP) and for
+      # its event-loop wakeup (CHLD). A child that kept those handlers would
+      # ignore the SIGTERM sent while draining it and could write into the
+      # parent's wakeup pipe.
+      INHERITED_TRAPS = %w[INT TERM HUP CHLD].freeze
+
       # @param parent_pid [Integer] captured in the parent *before* Process.fork.
       #   Reading Process.ppid here instead would race the very death the
       #   watchdog is looking for: a parent that dies between fork and this
@@ -18,6 +24,7 @@ module Henitai
         # First, so that even a crash later in this method releases the
         # reports-directory lock rather than pinning it with an inherited fd.
         InheritedFdRegistry.close_all!
+        INHERITED_TRAPS.each { |signal| Signal.trap(signal, "DEFAULT") }
         Process.setpgid(0, 0)
         OrphanWatchdog.start(parent_pid:)
         nil

data/lib/henitai/integration/child_report_store.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+
+module Henitai
+  module Integration
+    # Carries a mutant child's report to the parent through a small JSON file
+    # next to the child's logs. The parent clears the file before each fork so
+    # a retry can never read the previous attempt's report.
+    class ChildReportStore
+      def write(path, data)
+        return unless path
+
+        FileUtils.mkdir_p(File.dirname(path))
+        temp_path = "#{path}.#{Process.pid}.tmp"
+        File.write(temp_path, JSON.generate(data))
+        File.rename(temp_path, path)
+        nil
+      end
+
+      def read(path)
+        return unless path && File.exist?(path)
+
+        JSON.parse(File.read(path))
+      rescue JSON::ParserError
+        nil
+      end
+
+      def clear(path)
+        FileUtils.rm_f(path) if path
+        nil
+      end
+    end
+  end
+end

data/lib/henitai/integration/minitest.rb

@@ -5,6 +5,7 @@ require "fileutils"
 # tail, by which point Base is already defined, so the require is skipped.
 require_relative "../integration" unless defined?(Henitai::Integration::Base)
 require_relative "minitest_load_path"
+require_relative "minitest_preload"
 require_relative "minitest_suite_command"
 require_relative "minitest_test_runner"
 require_relative "rails_environment_preloader"
@@ -18,6 +19,7 @@ module Henitai
     # but implements its own Minitest-specific test invocation and suite command.
     # Per-test coverage collection is not yet wired into this path.
     class Minitest < Base
+      include MinitestPreload
       include MutantRunSupport
       include RspecTestSelection
 
@@ -60,8 +62,8 @@ module Henitai
 
       private
 
-      def run_tests(test_files)
-        MinitestTestRunner.new.call(test_files)
+      def run_tests(test_files, outcomes, &)
+        MinitestTestRunner.new(preloaded: @minitest_preloaded == true).call(test_files, outcomes, &)
       end
 
       def subprocess_env
@@ -71,30 +73,38 @@ module Henitai
         env
       end
 
+      # `pgroup: true` makes the suite child a group leader, so the whole tree
+      # it spawns -- a Rails test server, browser drivers -- is signalable as
+      # one group. Without it the parent's `kill(:SIGTERM, -pid)` addresses a
+      # group that does not exist, raises ESRCH, and leaves a timed-out suite
+      # running to completion while the parent has already given up on it.
       def spawn_suite_process(test_files, log_paths)
         FileUtils.mkdir_p(File.dirname(log_paths[:stdout_path]))
         File.open(log_paths[:stdout_path], "w") do |stdout_file|
           File.open(log_paths[:stderr_path], "w") do |stderr_file|
             Process.spawn(
-              subprocess_env,
+              suite_process_env,
               *suite_command(test_files),
               out: stdout_file,
-              err: stderr_file
+              err: stderr_file,
+              pgroup: true
             )
           end
         end
       end
 
+      # A timeout has already torn the group down and reaped the child in
+      # `handle_timeout`; signalling again would only race a recycled pid.
       def cleanup_suite_process(pid, wait_result)
         return unless pid
 
-        cleanup_child_process(pid)
+        cleanup_process_group(pid) unless wait_result == :timeout
         reap_child(pid) if wait_result.nil?
       end
 
       def spec_files
-        (Dir.glob("test/**/*_test.rb") + Dir.glob("test/**/*_spec.rb"))
-          .reject { |f| f.start_with?("test/system/") }
+        @spec_files ||= (Dir.glob("test/**/*_test.rb") + Dir.glob("test/**/*_spec.rb"))
+                        .reject { |f| f.start_with?("test/system/") }
       end
     end
   end

data/lib/henitai/integration/minitest_autorun.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Henitai
+  module Integration
+    # Turns Minitest.autorun into a no-op, so that requiring test files never
+    # registers the at_exit hook that would run the suite a second time.
+    module MinitestAutorun
+      SUPPRESSOR = Module.new { def autorun = nil }
+
+      def self.suppress!
+        require "minitest"
+        singleton_class = ::Minitest.singleton_class
+        singleton_class.prepend(SUPPRESSOR) unless singleton_class.ancestors.include?(SUPPRESSOR)
+        nil
+      rescue LoadError, NameError
+        nil
+      end
+    end
+  end
+end

data/lib/henitai/integration/minitest_outcome_reporter.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require "minitest"
+require "henitai/test_file_outcomes"
+require "henitai/minitest_result_file"
+
+module Henitai
+  module Integration
+    # Records the outcome of each finished Minitest result per test file.
+    class MinitestOutcomeReporter < ::Minitest::Reporter
+      def initialize(outcomes, report_path: nil, io: $stdout)
+        super(io, {})
+        @outcomes = outcomes
+        @report_path = report_path
+      end
+
+      def record(result)
+        super
+        MinitestResultFile.record(@outcomes, result)
+      end
+
+      def report
+        super
+        @outcomes.write(@report_path) if @report_path
+      end
+    end
+  end
+end

data/lib/henitai/integration/minitest_preload.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require_relative "minitest_autorun"
+require_relative "minitest_load_path"
+require_relative "rails_environment_preloader"
+
+module Henitai
+  module Integration
+    # Fork-server support for the Minitest integration (ADR-15): the server
+    # loads the environment and the union of the run's test files once, without
+    # running anything; each mutant process then runs only its own files.
+    module MinitestPreload
+      def fork_server_supported?
+        true
+      end
+
+      def preload_environment(test_files)
+        MinitestAutorun.suppress!
+        CoverageRuntimeSuppressors.suppress_simplecov!
+        CoverageRuntimeSuppressors.suppress_coverage!
+        subprocess_env.each { |key, value| ENV[key] = value }
+        MinitestLoadPath.ensure!
+        RailsEnvironmentPreloader.new.call
+        test_files.each { |file| require File.expand_path(file) }
+        @minitest_preloaded = true
+        nil
+      end
+    end
+  end
+end

data/lib/henitai/integration/minitest_runnable_filter.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "henitai/minitest_result_file"
+
+module Henitai
+  module Integration
+    # Narrows Minitest's registry of test classes to those defined in the given
+    # test files, for a process that inherited the union of a run's test files
+    # from the fork server (ADR-15). A class belongs to a file when one of its
+    # test methods is defined there.
+    class MinitestRunnableFilter
+      def initialize(test_files)
+        @wanted = test_files.to_set { |file| canonical(file) }
+      end
+
+      def apply!
+        with_seed { ::Minitest::Runnable.runnables.select! { |suite| defined_in_wanted_file?(suite) } }
+      end
+
+      private
+
+      # runnable_methods shuffles with Minitest.seed, which is unset before a run.
+      def with_seed
+        original = ::Minitest.seed
+        ::Minitest.seed ||= 0
+        yield
+      ensure
+        ::Minitest.seed = original
+      end
+
+      # A suite belongs to a file when its class is defined there, or when one
+      # of its test methods is. The class file covers tests inherited from a
+      # shared module, which report the module's file; the method check covers
+      # a class reopened in another file.
+      def defined_in_wanted_file?(suite)
+        wanted_class_file?(suite) || method_in_wanted_file?(suite)
+      rescue NotImplementedError, NameError
+        false
+      end
+
+      def wanted_class_file?(suite)
+        file = suite.name && MinitestResultFile.class_file_of(suite.name)
+        !file.nil? && @wanted.include?(canonical(file))
+      end
+
+      def method_in_wanted_file?(suite)
+        suite.runnable_methods.any? do |name|
+          location = suite.instance_method(name).source_location
+          location && @wanted.include?(canonical(location.first))
+        end
+      end
+
+      # Symlinked temp or checkout directories must not make one file two paths.
+      def canonical(path)
+        File.realpath(path)
+      rescue SystemCallError
+        File.expand_path(path)
+      end
+    end
+  end
+end

data/lib/henitai/integration/minitest_test_runner.rb

@@ -1,16 +1,32 @@
 # frozen_string_literal: true
 
-require_relative "coverage_suppression"
+require "henitai/integration/minitest_autorun"
+require "henitai/integration/minitest_outcome_reporter"
+require "henitai/integration/minitest_runnable_filter"
+require "henitai/test_file_outcomes"
 
 module Henitai
   module Integration
     # Runs Minitest test files in-process and normalizes the result to an
     # exit code, for Minitest#run_tests during a single mutant activation.
     class MinitestTestRunner
-      def call(test_files)
-        CoverageRuntimeSuppressors.suppress_simplecov!
-        suppress_autorun!
-        test_files.each { |file| require File.expand_path(file) }
+      PLUGIN_NAME = "henitai_outcomes"
+
+      # +preloaded+: the fork server already required the union of the run's
+      # test files, so only the ones requested here are kept to run.
+      def initialize(preloaded: false)
+        @preloaded = preloaded
+      end
+
+      # Yields once the test files are required and before Minitest runs; a
+      # falsy block result skips the run. Per-file outcomes are recorded into
+      # +outcomes+ through a Minitest reporter plugin.
+      def call(test_files, outcomes = TestFileOutcomes.new, &after_load)
+        MinitestAutorun.suppress!
+        load_tests(test_files)
+        return 1 if after_load && !after_load.call
+
+        install_outcome_plugin(outcomes)
         # @type var empty_args: Array[String]
         empty_args = []
         status = ::Minitest.run(empty_args)
@@ -21,18 +37,19 @@ module Henitai
 
       private
 
-      def suppress_autorun!
-        require "minitest"
-        singleton_class = ::Minitest.singleton_class
-        suppressor = @autorun_suppressor ||= Module.new.tap do |mod|
-          mod.define_method(:autorun) { nil }
+      def install_outcome_plugin(outcomes)
+        ::Minitest.extensions << PLUGIN_NAME unless ::Minitest.extensions.include?(PLUGIN_NAME)
+        init = :"plugin_#{PLUGIN_NAME}_init"
+        ::Minitest.singleton_class.send(:remove_method, init) if ::Minitest.respond_to?(init)
+        ::Minitest.define_singleton_method(init) do |_options|
+          reporter.reporters << MinitestOutcomeReporter.new(outcomes)
         end
-        return if singleton_class.ancestors.include?(suppressor)
+      end
 
-        singleton_class.prepend(suppressor)
-        nil
-      rescue LoadError, NameError
-        nil
+      def load_tests(test_files)
+        return MinitestRunnableFilter.new(test_files).apply! if @preloaded
+
+        test_files.each { |file| require File.expand_path(file) }
       end
     end
   end