evilution 0.31.0 → 0.33.0

data/lib/evilution/integration/rspec/state_guard/configuration_state.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative "../../rspec"
+
+# Restores the RSpec.configuration state that ::RSpec::Core::Runner.run mutates
+# on the shared singleton during an in-process mutation run (EV-dwqw / GH #1343).
+#
+# The visible symptom was every SUBSEQUENT host example rendering its progress
+# dots without color (white instead of green). Root cause: the run's args carry
+# "--no-color", and ConfigurationOptions#configure applies it via
+# Configuration#force, which does `@preferred_options.merge!(:color_mode => :off)`
+# IN PLACE. `Configuration#color_mode` reads `@preferred_options.fetch(:color_mode)`
+# first, so the host's color setting stays :off for the rest of the process.
+# Separately, Runner#setup points `output_stream`/`error_stream` (attr_writers,
+# i.e. the @output_stream/@error_stream ivars) at the run's throwaway StringIOs.
+#
+# Forked runs never leak these (the mutation happens in a child that dies); only
+# the in-process isolation path mutates the host's own configuration.
+#
+# @preferred_options is mutated in place, so it is snapshotted by DUP and put
+# back by replacing the ivar; the stream ivars are reassigned during the run,
+# so capturing the original references is enough.
+class Evilution::Integration::RSpec::StateGuard::ConfigurationState
+  PREFERRED_OPTIONS = :@preferred_options
+  STREAM_IVARS = %i[@output_stream @error_stream].freeze
+  ALL_IVARS = [PREFERRED_OPTIONS, *STREAM_IVARS].freeze
+
+  # configuration is injectable for isolated unit testing; production uses the
+  # shared RSpec.configuration singleton.
+  def initialize(configuration: nil)
+    @configuration = configuration
+  end
+
+  def snapshot
+    config = configuration
+    state = {}
+    capture_preferred_options(config, state)
+    STREAM_IVARS.each do |ivar|
+      state[ivar] = config.instance_variable_get(ivar) if config.instance_variable_defined?(ivar)
+    end
+    state
+  end
+
+  # Restore exactly the pre-run state: ivars present at snapshot get their value
+  # back; ivars created by the run but absent before are removed, so nothing the
+  # run introduced can leak into the host either.
+  def release(captured)
+    return unless captured
+
+    config = configuration
+    ALL_IVARS.each do |ivar|
+      if captured.key?(ivar)
+        config.instance_variable_set(ivar, captured[ivar])
+      elsif config.instance_variable_defined?(ivar)
+        config.remove_instance_variable(ivar)
+      end
+    end
+  end
+
+  private
+
+  def configuration
+    @configuration || ::RSpec.configuration
+  end
+
+  def capture_preferred_options(config, state)
+    return unless config.instance_variable_defined?(PREFERRED_OPTIONS)
+
+    value = config.instance_variable_get(PREFERRED_OPTIONS)
+    state[PREFERRED_OPTIONS] = value.is_a?(Hash) ? value.dup : value
+  end
+end

data/lib/evilution/integration/rspec/state_guard/configuration_streams.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative "../../rspec"
+require_relative "internals"
+
+# Restores the RSpec.configuration fields that ::RSpec::Core::Runner.run mutates
+# on the shared singleton during an in-process mutation run (EV-dwqw / GH #1343):
+#
+#   - @color_mode    -- the run's args carry "--no-color", flipping it to :off,
+#                       which makes every SUBSEQUENT host example render its
+#                       progress dots without color (white instead of green).
+#   - @output_stream -- Runner#setup swaps it to the run's StringIO whenever the
+#                       host's was $stdout.
+#   - @error_stream  -- likewise pointed at the run's StringIO.
+#
+# Forked runs never leak these (the mutation happens in a child that dies), but
+# the in-process isolation path mutates the host's own configuration. Restore by
+# writing the ivars directly: configuration#output_stream= is guarded (it warns
+# and no-ops once a reporter exists), so the public setter cannot put it back.
+class Evilution::Integration::RSpec::StateGuard::ConfigurationStreams
+  IVARS = %i[@color_mode @output_stream @error_stream].freeze
+
+  def snapshot
+    config = ::RSpec.configuration
+    IVARS.each_with_object({}) do |ivar, acc|
+      acc[ivar] = config.instance_variable_get(ivar) if config.instance_variable_defined?(ivar)
+    end
+  end
+
+  # Restore exactly the pre-run state: ivars present at snapshot get their value
+  # back; ivars that were absent before but created by the run are removed, so a
+  # newly-defined ivar can't leak into the host either.
+  def release(captured)
+    return unless captured
+
+    config = ::RSpec.configuration
+    IVARS.each do |ivar|
+      if captured.key?(ivar)
+        config.instance_variable_set(ivar, captured[ivar])
+      elsif config.instance_variable_defined?(ivar)
+        config.remove_instance_variable(ivar)
+      end
+    end
+  end
+end

data/lib/evilution/integration/rspec/state_guard.rb

@@ -7,6 +7,7 @@ require_relative "state_guard/world_sources_by_path"
 require_relative "state_guard/world_filtered_examples"
 require_relative "state_guard/reporter_arrays"
 require_relative "state_guard/example_groups_constants"
+require_relative "state_guard/configuration_state"
 
 class Evilution::Integration::RSpec::StateGuard
   DEFAULT_STRATEGIES = [
@@ -15,7 +16,8 @@ class Evilution::Integration::RSpec::StateGuard
     WorldSourcesByPath.new,
     WorldFilteredExamples.new,
     ReporterArrays.new,
-    ExampleGroupsConstants.new
+    ExampleGroupsConstants.new,
+    ConfigurationState.new
   ].freeze
 
   def initialize(strategies: DEFAULT_STRATEGIES)

data/lib/evilution/integration/test_unit/dispatcher.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require "stringio"
+require_relative "../test_unit"
+
+# Builds a Test::Unit::TestSuite from a list of TestCase subclasses and runs
+# it via the console runner with output captured to a StringIO. Owning this
+# responsibility separately keeps the runner library require + suite assembly
+# in one place — used by both the baseline path (Evilution::Integration::TestUnit
+# .run_baseline_test_file) and the per-mutation path (#run_tests).
+module Evilution::Integration::TestUnit::Dispatcher
+  module_function
+
+  def call(test_case_classes, name: "evilution")
+    require "test/unit/ui/console/testrunner"
+    suite = ::Test::Unit::TestSuite.new(name)
+    test_case_classes.each { |klass| suite << klass.suite }
+    out = StringIO.new
+    runner = ::Test::Unit::UI::Console::TestRunner.new(suite, output: out)
+    runner.start
+  end
+
+  def test_method_count(test_case_classes)
+    test_case_classes.sum { |klass| klass.suite.tests.length }
+  end
+end

data/lib/evilution/integration/test_unit/framework_loader.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require_relative "../test_unit"
+
+# Loads the test-unit gem and disables its at_exit auto-run handler.
+# Mirrors Evilution::Integration::RSpec::FrameworkLoader's role: framework
+# setup is one responsibility separated from dispatch + result building so
+# integrations can compose it independently in tests.
+class Evilution::Integration::TestUnit::FrameworkLoader
+  def loaded?
+    @loaded == true
+  end
+
+  def call
+    return if @loaded
+
+    require "test-unit"
+    self.class.stub_autorun!
+    @loaded = true
+  rescue LoadError => e
+    raise Evilution::Error, "test-unit is required but not available: #{e.message}"
+  end
+
+  # User code that `require "test-unit"` installs an at_exit hook that calls
+  # Test::Unit::AutoRunner.run when need_auto_run? is true. At evilution exit
+  # ARGV still holds evilution flags and the runner prints a misleading banner.
+  # Flipping need_auto_run = false prevents the handler from firing.
+  def self.stub_autorun!
+    return unless defined?(::Test::Unit::AutoRunner)
+
+    ::Test::Unit::AutoRunner.need_auto_run = false
+  end
+end

data/lib/evilution/integration/test_unit/result_builder.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require_relative "../test_unit"
+
+# Shapes the result Hash that flows back to Evilution::Result::MutationResult
+# / classify_status. Three orthogonal flavours — pass/fail/crash, no tests
+# executed, and unresolved spec — each have their own change axis (e.g. the
+# no-tests-ran error string evolved separately as the test-unit framework
+# diagnostic improved). Putting them behind a single object documents the
+# contract and lets the integration class drop them.
+module Evilution::Integration::TestUnit::ResultBuilder
+  module_function
+
+  def call(passed:, command:, detector:)
+    if passed
+      { passed: true, test_command: command }
+    elsif detector.only_crashes?
+      crash(command, detector)
+    else
+      { passed: false, test_command: command }
+    end
+  end
+
+  def no_tests_ran(command)
+    {
+      passed: false,
+      error: "no Test::Unit tests executed (0 test methods ran) — the resolved " \
+             "spec registered no Test::Unit suite. Check --integration/--spec.",
+      error_class: "Evilution::Error",
+      test_command: command
+    }
+  end
+
+  def unresolved(mutation_file_path)
+    {
+      passed: false,
+      unresolved: true,
+      error: "no matching test resolved for #{mutation_file_path}",
+      test_command: "ruby -Itest (skipped: no test resolved for #{mutation_file_path})"
+    }
+  end
+
+  def crash(command, detector)
+    classes = detector.unique_crash_classes
+    {
+      passed: false,
+      test_crashed: true,
+      error: "test crashes: #{detector.crash_summary}",
+      error_class: (classes.first if classes.length == 1),
+      test_command: command
+    }
+  end
+end

data/lib/evilution/integration/test_unit/subject_class_registry.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+require_relative "../test_unit"
+
+# Tracks Test::Unit::TestCase descendants in the host process. Test::Unit has
+# no public registry-clear method analogous to Minitest::Runnable.runnables;
+# the integration scopes each dispatch to classes that appeared during *this*
+# round by diffing the descendant set before and after #load. Keeping that
+# responsibility in its own object makes it cheap to stub in tests and lets
+# the integration's main class read as orchestration.
+module Evilution::Integration::TestUnit::SubjectClassRegistry
+  module_function
+
+  def descendants
+    return [] unless defined?(::Test::Unit::TestCase)
+
+    ObjectSpace.each_object(Class).select { |c| c < ::Test::Unit::TestCase }
+  end
+
+  # Yields, captures the descendant set before/after, and returns the diff.
+  def newly_loaded
+    before = descendants
+    yield
+    descendants - before
+  end
+end

data/lib/evilution/integration/test_unit/test_file_resolver.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require_relative "../test_unit"
+
+# Resolves the list of test files to load for a given mutation. Encapsulates
+# the explicit-override path, spec-selector lookup, fallback glob, and the
+# warn-once behaviour for unresolved sources. The integration class would
+# otherwise carry both per-instance test resolution state (@test_files,
+# @spec_selector, @warned_files, @fallback_to_full_suite) and dispatch
+# orchestration in the same object; splitting them gives the resolver its
+# own change axis (e.g. adding new resolution heuristics) independent of
+# the runner.
+class Evilution::Integration::TestUnit::TestFileResolver
+  def initialize(test_files:, spec_selector:, fallback_to_full_suite:)
+    @test_files = test_files
+    @spec_selector = spec_selector
+    @fallback_to_full_suite = fallback_to_full_suite
+    @warned_files = Set.new
+  end
+
+  # Returns the resolved file list, or nil if the source could not be
+  # resolved and fallback is disabled.
+  def call(mutation_file_path)
+    return @test_files if @test_files
+
+    resolved = Array(@spec_selector.call(mutation_file_path))
+    return resolved unless resolved.empty?
+
+    warn_unresolved(mutation_file_path)
+    @fallback_to_full_suite ? glob_test_files : nil
+  end
+
+  private
+
+  def glob_test_files
+    files = Dir.glob("test/**/*_test.rb")
+    files.empty? ? ["test"] : files
+  end
+
+  def warn_unresolved(file_path)
+    return if @warned_files.include?(file_path)
+
+    @warned_files << file_path
+    action = @fallback_to_full_suite ? "running full suite" : "marking mutation unresolved"
+    warn "[evilution] No matching test found for #{file_path}, #{action}. " \
+         "Use --spec to specify the test file."
+  end
+end

data/lib/evilution/integration/test_unit.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require_relative "base"
+require_relative "test_unit_crash_detector"
+require_relative "loading/test_load_path"
+require_relative "../spec_resolver"
+require_relative "../spec_selector"
+
+require_relative "../integration"
+
+# Test::Unit integration. Decomposed under lib/evilution/integration/test_unit/
+# mirroring the RSpec integration's layout. This class is the orchestrator:
+# it wires the framework loader, dispatcher, subject-class registry,
+# test-file resolver, and result builder. The class is registered under
+# Evilution::Runner::INTEGRATIONS[:test_unit] and reachable via the
+# `--integration test-unit` CLI flag.
+class Evilution::Integration::TestUnit < Evilution::Integration::Base
+  def self.baseline_runner
+    ->(test_file) { run_baseline_test_file(test_file) }
+  end
+
+  # SpecResolver tuned for the dominant Test::Unit layout: tests live under
+  # test/, named with the _test.rb suffix (the same convention Minitest uses).
+  # Rails plugins on the test-unit gem (e.g. kaminari-core) follow this layout.
+  # The test/test_<name>.rb prefix-style convention is rare enough in practice
+  # that we defer support to a follow-up if a project surfaces needing it.
+  def self.spec_resolver
+    Evilution::SpecResolver.new(test_dir: "test", test_suffix: "_test.rb", request_dir: "integration")
+  end
+
+  def self.baseline_options
+    {
+      runner: baseline_runner,
+      spec_resolver: spec_resolver,
+      fallback_dir: "test"
+    }
+  end
+
+  def self.run_baseline_test_file(test_file)
+    require_relative "test_unit/framework_loader"
+    require_relative "test_unit/subject_class_registry"
+    require_relative "test_unit/dispatcher"
+    FrameworkLoader.new.call
+    files = baseline_test_files(test_file)
+    Evilution::Integration::Loading::TestLoadPath.add!(files)
+    new_classes = SubjectClassRegistry.newly_loaded do
+      files.each { |f| load(File.expand_path(f)) }
+    end
+    Dispatcher.call(new_classes, name: "evilution baseline").passed?
+  end
+
+  def self.baseline_test_files(test_file)
+    File.directory?(test_file) ? Dir.glob(File.join(test_file, "**/*_test.rb")) : [test_file]
+  end
+
+  def initialize(test_files: nil, hooks: nil, fallback_to_full_suite: false, spec_selector: nil)
+    require_relative "test_unit/framework_loader"
+    require_relative "test_unit/subject_class_registry"
+    require_relative "test_unit/dispatcher"
+    require_relative "test_unit/test_file_resolver"
+    require_relative "test_unit/result_builder"
+    @framework_loader = FrameworkLoader.new
+    @file_resolver = TestFileResolver.new(
+      test_files: test_files,
+      spec_selector: spec_selector || Evilution::SpecSelector.new(spec_resolver: self.class.spec_resolver),
+      fallback_to_full_suite: fallback_to_full_suite
+    )
+    @crash_detector = nil
+    super(hooks: hooks)
+  end
+
+  private
+
+  def ensure_framework_loaded
+    return if @framework_loader.loaded?
+
+    fire_hook(:setup_integration_pre, integration: :test_unit)
+    @framework_loader.call
+    fire_hook(:setup_integration_post, integration: :test_unit)
+  end
+
+  def run_tests(mutation)
+    ensure_framework_loaded
+    reset_state
+    files = @file_resolver.call(mutation.file_path)
+    return ResultBuilder.unresolved(mutation.file_path) if files.nil?
+
+    command = "ruby -Itest #{files.join(" ")}"
+    execute_test_unit(files, command)
+  rescue StandardError => e
+    { passed: false, error: e.message, test_command: command }
+  end
+
+  def execute_test_unit(files, command)
+    new_classes = load_test_classes(files)
+    return ResultBuilder.no_tests_ran(command) if Dispatcher.test_method_count(new_classes).zero?
+
+    detector = reset_crash_detector
+    result = Dispatcher.call(new_classes, name: "evilution-mutation")
+    result.faults.each { |fault| detector.record(fault) }
+    ResultBuilder.call(passed: result.passed?, command: command, detector: detector)
+  end
+
+  def load_test_classes(files)
+    Evilution::Integration::Loading::TestLoadPath.add!(files)
+    SubjectClassRegistry.newly_loaded do
+      files.each { |f| load(File.expand_path(f, Evilution.project_base_dir)) }
+    end
+  end
+
+  # Test::Unit has no public registry-clear analogous to
+  # Minitest::Runnable.runnables.clear. SubjectClassRegistry's newly_loaded
+  # block scopes each dispatch to classes loaded in *this* round, so stale
+  # classes from prior mutations sit dormant on ObjectSpace without polluting
+  # the run. #reset_state stays as a contract no-op for parity with Minitest.
+  def reset_state
+    # no-op — see comment above
+  end
+
+  def build_args(_mutation)
+    []
+  end
+
+  def reset_crash_detector
+    if @crash_detector
+      @crash_detector.reset
+    else
+      @crash_detector = Evilution::Integration::TestUnitCrashDetector.new
+    end
+    @crash_detector
+  end
+end

data/lib/evilution/integration/test_unit_crash_detector.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require_relative "../integration"
+
+# Test::Unit analog of Evilution::Integration::MinitestCrashDetector. Tracks
+# whether a Test::Unit test run produced only crashes (exceptions captured as
+# Test::Unit::Error) vs assertion failures (Test::Unit::Failure). When only
+# crashes occur, the mutation result can carry crash details while remaining
+# classified as :killed — see classify_status / Result::MutationResult.
+#
+# Hook the detector into a Test::Unit::TestResult via .attach(result), or
+# call #record(fault) directly when iterating a finished result's #faults.
+class Evilution::Integration::TestUnitCrashDetector
+  def initialize
+    reset
+  end
+
+  def reset
+    @assertion_failures = 0
+    @crashes = []
+  end
+
+  def attach(test_result)
+    require "test/unit/testresult"
+    test_result.add_listener(Test::Unit::TestResult::FAULT) { |fault| record(fault) }
+  end
+
+  def record(fault)
+    if fault.is_a?(Test::Unit::Error)
+      @crashes << fault.exception
+    elsif fault.is_a?(Test::Unit::Failure)
+      @assertion_failures += 1
+    end
+  end
+
+  def passed?
+    @assertion_failures.zero? && @crashes.empty?
+  end
+
+  def assertion_failure?
+    @assertion_failures.positive?
+  end
+
+  def crashed?
+    @crashes.any?
+  end
+
+  def only_crashes?
+    @crashes.any? && @assertion_failures.zero?
+  end
+
+  def unique_crash_classes
+    @crashes.map { |e| e.class.name }.uniq
+  end
+
+  def crash_summary
+    return nil if @crashes.empty?
+
+    "#{unique_crash_classes.join(", ")} (#{@crashes.length} crash#{"es" unless @crashes.length == 1})"
+  end
+end

data/lib/evilution/isolation/fork.rb

@@ -11,6 +11,7 @@ require_relative "../isolation"
 
 class Evilution::Isolation::Fork
   GRACE_PERIOD = 2
+  REAP_DEADLINE = 1.0
 
   def initialize(hooks: nil)
     @hooks = hooks
@@ -47,6 +48,7 @@ class Evilution::Isolation::Fork
 
   def fork_child(read_io, write_io, sandbox_dir, mutation, test_command)
     ::Process.fork do
+      isolate_into_own_process_group
       ENV["TMPDIR"] = sandbox_dir
       # Path-relativizing mutations (e.g. File.join(dir, name) -> name) would
       # otherwise write into the parent's CWD (typically the repo root) and
@@ -69,6 +71,21 @@ class Evilution::Isolation::Fork
     end
   end
 
+  # EV-2sh8 / GH #1330: make the mutation child its own process-group leader as
+  # its very first act, before it runs test_command (which may fork blocking
+  # grandchildren -- e.g. connection_pool / ractor / thread subject specs).
+  # Grandchildren then inherit this group, so terminate_child can group-kill the
+  # whole subtree on timeout. Without it, a blocking grandchild orphans to init
+  # and survives the rest of the run -- the inner path never SIGKILLs the worker,
+  # so EV-cnx8's outer process-group kill never sweeps it. Done child-side (not
+  # parent-side as in Worker) because the per-mutation timeout fires seconds
+  # later, long after this line has run, so no fork-before-setpgid race exists.
+  def isolate_into_own_process_group
+    ::Process.setpgid(0, 0)
+  rescue SystemCallError
+    nil
+  end
+
   def cleanup_resources(read_io, write_io, pid, sandbox_dir)
     read_io.close unless read_io.nil?
     write_io.close unless write_io.nil?
@@ -130,8 +147,23 @@ class Evilution::Isolation::Fork
     end
   end
 
+  # Process.wait without a deadline can hang the parent indefinitely. The
+  # per-mutation child may already have written a payload (or a grandchild may
+  # have written garbage that looks like one) while the child itself is stuck
+  # in execute_in_child waiting on a subject grandchild the mutation broke.
+  # wait_for_result has already returned by this point, so the per-mutation
+  # timeout cannot fire. Bound the wait and fall back to the TERM/KILL ladder.
   def reap_and_decode(pid, payload)
-    ::Process.wait(pid)
+    deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + REAP_DEADLINE
+    loop do
+      break if ::Process.waitpid(pid, ::Process::WNOHANG)
+
+      if Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
+        terminate_child(pid)
+        break
+      end
+      sleep 0.05
+    end
     decode_payload(payload)
   end
 
@@ -200,7 +232,7 @@ class Evilution::Isolation::Fork
   end
 
   def terminate_child(pid)
-    Evilution::ProcessCleanup.safe_kill("TERM", pid)
+    signal_tree("TERM", pid)
     _, status = ::Process.waitpid2(pid, ::Process::WNOHANG)
     return if status
 
@@ -208,10 +240,20 @@ class Evilution::Isolation::Fork
     _, status = ::Process.waitpid2(pid, ::Process::WNOHANG)
     return if status
 
-    Evilution::ProcessCleanup.safe_kill("KILL", pid)
+    signal_tree("KILL", pid)
     Evilution::ProcessCleanup.safe_wait(pid)
   end
 
+  # Signal the child's whole process group (-pid) to sweep any grandchildren it
+  # forked, then the bare pid as a fallback for the case where setpgid failed
+  # (no group exists, so the group signal is a harmless Errno::ESRCH). Only the
+  # leader pid is reaped here -- group-killed grandchildren are not our direct
+  # children, so init reaps them once they die.
+  def signal_tree(sig, pid)
+    Evilution::ProcessCleanup.safe_kill(sig, -pid)
+    Evilution::ProcessCleanup.safe_kill(sig, pid)
+  end
+
   def classify_status(result)
     return :timeout if result[:timeout]
     return :killed if result[:test_crashed]

data/lib/evilution/mcp/info_tool.rb

@@ -58,8 +58,8 @@ class Evilution::MCP::InfoTool < MCP::Tool
       },
       integration: {
         type: "string",
-        description: "[subjects, tests] Test integration (rspec, minitest) — 'tests' selects " \
-                     "the matching spec resolver (spec/*_spec.rb for rspec, test/*_test.rb for minitest)"
+        description: "[subjects, tests] Test integration (rspec, minitest, test-unit) — 'tests' selects " \
+                     "the matching spec resolver (spec/*_spec.rb for rspec, test/*_test.rb for minitest/test-unit)"
       },
       skip_config: {
         type: "boolean",

data/lib/evilution/mcp/mutate_tool.rb

@@ -72,8 +72,9 @@ class Evilution::MCP::MutateTool < MCP::Tool
       },
       integration: {
         type: "string",
-        enum: %w[rspec minitest],
-        description: "Test integration to use (default: rspec)"
+        enum: %w[rspec minitest test-unit],
+        description: "Test integration to use (default: rspec). " \
+                     "Use test-unit for projects whose suites run on the test-unit gem."
       },
       isolation: {
         type: "string",