evilution 0.26.0 → 0.27.0

data/lib/evilution/runner/mutation_executor/strategy/parallel.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+class Evilution::Runner; end unless defined?(Evilution::Runner) # rubocop:disable Lint/EmptyClass
+class Evilution::Runner::MutationExecutor; end unless defined?(Evilution::Runner::MutationExecutor) # rubocop:disable Lint/EmptyClass
+module Evilution::Runner::MutationExecutor::Strategy; end unless defined?(Evilution::Runner::MutationExecutor::Strategy)
+
+class Evilution::Runner::MutationExecutor::Strategy::Parallel
+  def initialize(cache:, isolator:, packer:, pipeline:, notifier:, pool_factory:, config:, diagnostics: nil)
+    @cache = cache
+    @isolator = isolator
+    @packer = packer
+    @pipeline = pipeline
+    @notifier = notifier
+    @pool_factory = pool_factory
+    @diagnostics = diagnostics
+    @config = config
+  end
+
+  def call(mutations, baseline_result:, integration:)
+    @notifier.start(mutations.length)
+    pool = @pool_factory.call
+    state = { results: [], truncated: false, completed: 0 }
+    all_worker_stats = []
+
+    mutations.each_slice(@config.jobs) do |batch|
+      break if state[:truncated]
+
+      batch_results = run_batch(batch, pool, integration)
+      all_worker_stats.concat(pool.worker_stats)
+      process_batch(batch_results, baseline_result, state)
+    end
+
+    @diagnostics.log_worker_stats(@diagnostics.aggregate_worker_stats(all_worker_stats)) if @diagnostics
+    @notifier.finish
+    [state[:results], state[:truncated]]
+  end
+
+  private
+
+  def run_batch(batch, pool, integration)
+    uncached_indices, cached_results = @cache.partition(batch, packer: @packer)
+    worker_results = run_uncached(batch, uncached_indices, pool, integration)
+    compact_results = merge(batch, uncached_indices, cached_results, worker_results)
+    batch_results = batch.zip(compact_results).map { |m, h| @packer.rebuild(m, h) }
+    uncached_indices.each { |i| @cache.store(batch_results[i].mutation, batch_results[i]) }
+    batch.each(&:strip_sources!)
+    batch_results
+  end
+
+  def run_uncached(batch, uncached_indices, pool, integration)
+    return [] if uncached_indices.empty?
+
+    uncached = uncached_indices.map { |i| batch[i] }
+    pool.map(uncached) do |mutation|
+      test_command = ->(m) { integration.call(m) }
+      result = @isolator.call(mutation: mutation, test_command: test_command, timeout: @config.timeout)
+      @packer.compact(result)
+    end
+  end
+
+  def merge(batch, uncached_indices, cached_results, worker_results)
+    result_map = cached_results.dup
+    uncached_indices.each_with_index { |batch_idx, worker_idx| result_map[batch_idx] = worker_results[worker_idx] }
+    batch.each_index.map { |i| result_map[i] }
+  end
+
+  def process_batch(batch_results, baseline_result, state)
+    batch_results.each do |result|
+      result = @pipeline.call(result, baseline_result: baseline_result)
+      state[:results] << result
+      state[:completed] += 1
+      if @notifier.notify(result, state[:completed]) == :truncate
+        state[:truncated] = true
+        break
+      end
+    end
+
+    @diagnostics.log_memory("after batch", "#{state[:completed]} complete") if @diagnostics
+  end
+end

data/lib/evilution/runner/mutation_executor/strategy/sequential.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+class Evilution::Runner; end unless defined?(Evilution::Runner) # rubocop:disable Lint/EmptyClass
+class Evilution::Runner::MutationExecutor; end unless defined?(Evilution::Runner::MutationExecutor) # rubocop:disable Lint/EmptyClass
+module Evilution::Runner::MutationExecutor::Strategy; end unless defined?(Evilution::Runner::MutationExecutor::Strategy)
+
+class Evilution::Runner::MutationExecutor::Strategy::Sequential
+  def initialize(runner:, pipeline:, notifier:)
+    @runner = runner
+    @pipeline = pipeline
+    @notifier = notifier
+  end
+
+  def call(mutations, baseline_result:, integration:)
+    @notifier.start(mutations.length)
+    results = []
+    truncated = false
+
+    mutations.each_with_index do |mutation, index|
+      result = @runner.call(mutation, integration: integration)
+      mutation.strip_sources!
+      result = @pipeline.call(result, baseline_result: baseline_result)
+      results << result
+
+      if @notifier.notify(result, index + 1) == :truncate
+        truncated = true
+        break
+      end
+    end
+
+    @notifier.finish
+    [results, truncated]
+  end
+end

data/lib/evilution/runner/mutation_executor.rb

@@ -1,325 +1,94 @@
 # frozen_string_literal: true
 
 require_relative "../parallel/pool"
-require_relative "../reporter/progress_bar"
-require_relative "../result/mutation_result"
+require_relative "mutation_executor/result_cache"
+require_relative "mutation_executor/result_packer"
+require_relative "mutation_executor/result_notifier"
+require_relative "mutation_executor/mutation_runner"
+require_relative "mutation_executor/neutralization_pipeline"
+require_relative "mutation_executor/neutralizer/infra_error"
+require_relative "mutation_executor/neutralizer/baseline_failed"
+require_relative "mutation_executor/strategy/sequential"
+require_relative "mutation_executor/strategy/parallel"
 
 class Evilution::Runner; end unless defined?(Evilution::Runner) # rubocop:disable Lint/EmptyClass
 
 class Evilution::Runner::MutationExecutor
+  InfraError = Neutralizer::InfraError
+  BaselineFailed = Neutralizer::BaselineFailed
+  Sequential = Strategy::Sequential
+  Parallel = Strategy::Parallel
+
   def initialize(config, isolator:, baseline_runner:, cache:, hooks:, diagnostics:, on_result: nil)
     @config = config
     @isolator = isolator
     @baseline_runner = baseline_runner
-    @cache = cache
+    @cache = ResultCache.new(cache)
+    @packer = ResultPacker.new
     @hooks = hooks
     @diagnostics = diagnostics
     @on_result = on_result
   end
 
   def call(mutations, baseline_result = nil)
-    @progress_bar = build_progress_bar(mutations.length)
-    result = if config.jobs > 1
-               run_parallel(mutations, baseline_result)
-             else
-               run_sequential(mutations, baseline_result)
-             end
-    @progress_bar&.finish
-    result
+    integration = @baseline_runner.build_integration
+    spec_resolver = baseline_failed?(baseline_result) ? @baseline_runner.neutralization_resolver : nil
+    notifier = build_notifier
+    pipeline = build_pipeline(spec_resolver)
+    strategy = @config.jobs > 1 ? build_parallel(notifier, pipeline) : build_sequential(notifier, pipeline)
+
+    strategy.call(mutations, baseline_result: baseline_result, integration: integration)
   end
 
   private
 
-  attr_reader :config, :isolator, :baseline_runner, :cache, :hooks, :diagnostics, :on_result
-
-  def run_sequential(mutations, baseline_result)
-    integration = baseline_runner.build_integration
-    spec_resolver = baseline_result&.failed? ? baseline_runner.neutralization_resolver : nil
-    results = []
-    survived_count = 0
-    truncated = false
-
-    mutations.each_with_index do |mutation, index|
-      result = execute_one(mutation, integration)
-      mutation.strip_sources!
-      result = neutralize_if_infra_error(result)
-      result = neutralize_if_baseline_failed(result, baseline_result, spec_resolver)
-      results << result
-      survived_count += 1 if result.survived?
-      notify_result(result, index + 1)
-
-      if config.fail_fast? && survived_count >= config.fail_fast
-        truncated = true
-        break
-      end
-    end
-
-    [results, truncated]
+  def baseline_failed?(baseline_result)
+    baseline_result && baseline_result.failed?
   end
 
-  def run_parallel(mutations, baseline_result)
-    integration = baseline_runner.build_integration
-    pool = build_pool
-    spec_resolver = baseline_result&.failed? ? baseline_runner.neutralization_resolver : nil
-    state = { results: [], survived_count: 0, truncated: false, completed: 0 }
-    all_worker_stats = []
-
-    mutations.each_slice(config.jobs) do |batch|
-      break if state[:truncated]
-
-      batch_results = run_parallel_batch(batch, pool, isolator, integration)
-      all_worker_stats.concat(pool.worker_stats)
-      process_batch(batch_results, baseline_result, spec_resolver, state)
-    end
-
-    diagnostics.log_worker_stats(diagnostics.aggregate_worker_stats(all_worker_stats))
-    [state[:results], state[:truncated]]
+  def build_notifier
+    ResultNotifier.new(@config, diagnostics: @diagnostics, on_result: @on_result)
   end
 
-  def build_pool
-    Evilution::Parallel::Pool.new(
-      size: config.jobs,
-      hooks: hooks,
-      item_timeout: config.timeout ? config.timeout * 2 : nil
+  def build_pipeline(spec_resolver)
+    NeutralizationPipeline.new(
+      [
+        InfraError.new,
+        BaselineFailed.new(
+          config: @config,
+          spec_resolver: spec_resolver || ->(_f) {},
+          fallback_dir: @baseline_runner.neutralization_fallback_dir
+        )
+      ]
     )
   end
 
-  def run_parallel_batch(batch, pool, worker_isolator, integration)
-    uncached_indices, cached_results = partition_cached(batch)
-    worker_results = run_uncached_workers(batch, uncached_indices, pool, worker_isolator, integration)
-    compact_results = merge_parallel_results(batch, uncached_indices, cached_results, worker_results)
-    batch.each(&:strip_sources!)
-    batch_results = rebuild_results(batch, compact_results)
-    batch_results.each { |r| store_cached_result(r.mutation, r) }
-    batch_results
-  end
-
-  def run_uncached_workers(batch, uncached_indices, pool, worker_isolator, integration)
-    return [] if uncached_indices.empty?
-
-    uncached = uncached_indices.map { |i| batch[i] }
-    pool.map(uncached) do |mutation|
-      test_command = ->(m) { integration.call(m) }
-      result = worker_isolator.call(mutation: mutation, test_command: test_command, timeout: config.timeout)
-      compact_result(result)
-    end
-  end
-
-  def process_batch(batch_results, baseline_result, spec_resolver, state)
-    batch_results.each do |result|
-      result = neutralize_if_infra_error(result)
-      result = neutralize_if_baseline_failed(result, baseline_result, spec_resolver)
-      state[:results] << result
-      state[:survived_count] += 1 if result.survived?
-      state[:completed] += 1
-      notify_result(result, state[:completed])
-    end
-
-    diagnostics.log_memory("after batch", "#{state[:completed]} complete")
-    state[:truncated] = true if should_truncate?(state[:survived_count])
-  end
-
-  # Reclassify results as :neutral when the failure was caused by test
-  # infrastructure rather than by the mutation. Two independent paths:
-  #
-  # 1) :error from a missing require / spec_helper / rails_helper / spec/support
-  #    initialization — detected by error_class ∈ INFRA_ERROR_CLASSES and
-  #    first backtrace frame matching INFRA_BACKTRACE_PATHS. Origin-only match
-  #    (not `any?`): Ruby backtraces typically carry spec_helper frames below
-  #    mutation-caused errors, so matching any frame would misclassify real
-  #    mutation NameError/LoadError as :neutral.
-  #
-  # 2) :killed from a CrashDetector test_crashed whose sole crash class is in
-  #    INFRA_CRASH_CLASSES (ActiveRecord::StatementTimeout, Timeout::Error,
-  #    etc.). These surface under parallel workers sharing a DB file or on a
-  #    slow CI; fork.rb initially reports them as :killed, and without this
-  #    demotion the kill count inflates with infra noise. No backtrace check:
-  #    the single-class signal from CrashDetector already rules out mixed
-  #    mutation-caused failures. See EV-toid / GH #814.
-  INFRA_ERROR_CLASSES = %w[LoadError NameError].freeze
-  INFRA_BACKTRACE_PATHS = %r{(?:^|/)(?:spec_helper\.rb|rails_helper\.rb|spec/support/)}
-  INFRA_CRASH_CLASSES = %w[
-    Timeout::Error
-    ActiveRecord::StatementTimeout
-    ActiveRecord::Deadlocked
-    ActiveRecord::ConnectionTimeoutError
-    ActiveRecord::LockWaitTimeout
-    SQLite3::BusyException
-  ].freeze
-  private_constant :INFRA_ERROR_CLASSES, :INFRA_BACKTRACE_PATHS, :INFRA_CRASH_CLASSES
-
-  def neutralize_if_infra_error(result)
-    return neutralize(result) if infra_crash?(result)
-    return result unless result.error?
-    return result unless INFRA_ERROR_CLASSES.include?(result.error_class)
-    return result unless infra_origin?(result.error_backtrace)
-
-    neutralize(result)
-  end
-
-  def infra_crash?(result)
-    result.killed? && INFRA_CRASH_CLASSES.include?(result.error_class)
-  end
-
-  def infra_origin?(backtrace)
-    frames = Array(backtrace)
-    return false if frames.empty?
-
-    frames.first =~ INFRA_BACKTRACE_PATHS ? true : false
-  end
-
-  def neutralize(result)
-    Evilution::Result::MutationResult.new(
-      mutation: result.mutation,
-      status: :neutral,
-      duration: result.duration,
-      test_command: result.test_command,
-      child_rss_kb: result.child_rss_kb,
-      memory_delta_kb: result.memory_delta_kb,
-      parent_rss_kb: result.parent_rss_kb,
-      error_message: result.error_message,
-      error_class: result.error_class,
-      error_backtrace: result.error_backtrace
+  def build_sequential(notifier, pipeline)
+    Sequential.new(
+      runner: MutationRunner.new(config: @config, cache: @cache, isolator: @isolator),
+      pipeline: pipeline,
+      notifier: notifier
     )
   end
 
-  def neutralize_if_baseline_failed(result, baseline_result, spec_resolver)
-    return result unless result.survived? && baseline_result && baseline_result.failed?
-
-    if config.spec_files.any?
-      should_neutralize = true
-    else
-      spec_file = spec_resolver.call(result.mutation.file_path) || baseline_runner.neutralization_fallback_dir
-      should_neutralize = baseline_result.failed_spec_files.include?(spec_file)
-    end
-    return result unless should_neutralize
-
-    neutralize(result)
-  end
-
-  def compact_result(result)
-    {
-      status: result.status,
-      duration: result.duration,
-      killing_test: result.killing_test,
-      test_command: result.test_command,
-      child_rss_kb: result.child_rss_kb,
-      memory_delta_kb: result.memory_delta_kb,
-      parent_rss_kb: result.parent_rss_kb,
-      error_message: result.error_message,
-      error_class: result.error_class,
-      error_backtrace: result.error_backtrace
-    }
-  end
-
-  def rebuild_results(batch, compact_results)
-    batch.zip(compact_results).map do |mutation, data|
-      Evilution::Result::MutationResult.new(
-        mutation: mutation,
-        status: data[:status],
-        duration: data[:duration],
-        killing_test: data[:killing_test],
-        test_command: data[:test_command],
-        child_rss_kb: data[:child_rss_kb],
-        memory_delta_kb: data[:memory_delta_kb],
-        parent_rss_kb: data[:parent_rss_kb],
-        error_message: data[:error_message],
-        error_class: data[:error_class],
-        error_backtrace: data[:error_backtrace]
-      )
-    end
-  end
-
-  def should_truncate?(survived_count)
-    config.fail_fast? && survived_count >= config.fail_fast
-  end
-
-  def partition_cached(batch)
-    uncached_indices = []
-    cached_results = {}
-
-    batch.each_with_index do |mutation, i|
-      if mutation.unparseable?
-        cached_results[i] = compact_result(build_unparseable_result(mutation))
-        next
-      end
-
-      cached = fetch_cached_result(mutation)
-      if cached
-        cached_results[i] = compact_result(cached)
-      else
-        uncached_indices << i
-      end
-    end
-
-    [uncached_indices, cached_results]
-  end
-
-  def execute_one(mutation, integration)
-    return build_unparseable_result(mutation) if mutation.unparseable?
-
-    execute_or_fetch(mutation) do
-      test_command = ->(m) { integration.call(m) }
-      isolator.call(mutation: mutation, test_command: test_command, timeout: config.timeout)
-    end
-  end
-
-  def build_unparseable_result(mutation)
-    Evilution::Result::MutationResult.new(mutation: mutation, status: :unparseable)
-  end
-
-  def merge_parallel_results(batch, uncached_indices, cached_results, worker_results)
-    result_map = cached_results.dup
-    uncached_indices.each_with_index { |batch_idx, worker_idx| result_map[batch_idx] = worker_results[worker_idx] }
-    batch.each_index.map { |i| result_map[i] }
-  end
-
-  def execute_or_fetch(mutation)
-    cached = fetch_cached_result(mutation)
-    return cached if cached
-
-    result = yield
-    store_cached_result(mutation, result)
-    result
-  end
-
-  def fetch_cached_result(mutation)
-    return nil unless cache
-
-    data = cache.fetch(mutation)
-    return nil unless data
-    return nil unless %i[killed timeout].include?(data[:status])
-
-    Evilution::Result::MutationResult.new(
-      mutation: mutation,
-      status: data[:status],
-      duration: data[:duration],
-      killing_test: data[:killing_test],
-      test_command: data[:test_command]
+  def build_parallel(notifier, pipeline)
+    Parallel.new(
+      cache: @cache,
+      isolator: @isolator,
+      packer: @packer,
+      pipeline: pipeline,
+      notifier: notifier,
+      pool_factory: -> { build_pool },
+      diagnostics: @diagnostics,
+      config: @config
     )
   end
 
-  def store_cached_result(mutation, result)
-    return unless cache
-    return unless result.killed? || result.timeout?
-
-    cache.store(mutation,
-                status: result.status,
-                duration: result.duration,
-                killing_test: result.killing_test,
-                test_command: result.test_command)
-  end
-
-  def notify_result(result, index)
-    on_result&.call(result)
-    @progress_bar&.tick(status: result.status)
-    diagnostics.log_progress(index, result.status)
-    diagnostics.log_mutation_diagnostics(result)
-  end
-
-  def build_progress_bar(total)
-    return nil if !config.progress? || config.quiet || config.verbose || !config.text? || !$stderr.tty?
-
-    Evilution::Reporter::ProgressBar.new(total: total, output: $stderr)
+  def build_pool
+    Evilution::Parallel::Pool.new(
+      size: @config.jobs,
+      hooks: @hooks,
+      item_timeout: @config.timeout ? @config.timeout * 2 : nil
+    )
   end
 end

data/lib/evilution/runner.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require "fileutils"
 require_relative "config"
 require_relative "ast/parser"
 require_relative "memory"
@@ -22,6 +23,7 @@ require_relative "session/store"
 require_relative "temp_dir_tracker"
 require_relative "rails_detector"
 require_relative "parallel_db_warning"
+require_relative "child_output"
 require_relative "runner/subject_pipeline"
 require_relative "runner/mutation_planner"
 require_relative "runner/isolation_resolver"
@@ -44,6 +46,7 @@ class Evilution::Runner
 
   def call
     install_signal_handlers
+    configure_child_output
     emit_parallel_db_warning
     start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
 
@@ -156,6 +159,24 @@ class Evilution::Runner
     Evilution::ParallelDbWarning.warn_if_sqlite_parallel(config)
   end
 
+  def configure_child_output
+    unless config.quiet_children
+      Evilution::ChildOutput.log_dir = nil
+      return
+    end
+
+    dir = config.quiet_children_dir
+    begin
+      FileUtils.rm_rf(dir)
+      FileUtils.mkdir_p(dir)
+    rescue SystemCallError => e
+      raise Evilution::ConfigError,
+            "quiet_children_dir #{dir.inspect} is not writable: #{e.class}: #{e.message}. " \
+            "Pass --quiet-children-dir <writable path> or drop --quiet-children."
+    end
+    Evilution::ChildOutput.log_dir = dir
+  end
+
   def install_signal_handlers
     %w[INT TERM].each { |sig| install_signal_handler(sig) }
   end

data/lib/evilution/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Evilution
-  VERSION = "0.26.0"
+  VERSION = "0.27.0"
 end