mutation_tester 1.2.0

data/lib/mutation_tester/configuration.rb

@@ -0,0 +1,105 @@
+require 'etc'
+
+module MutationTester
+  class Configuration
+    RUNNER_MODES = %i[auto fork spawn in_memory].freeze
+    AUTO_PARALLEL_CAP = 8
+
+    def self.auto_parallel_processes
+      [[Etc.nprocessors, AUTO_PARALLEL_CAP].min, 1].max
+    end
+
+    def self.worker_env_value(index)
+      number = index.to_i
+      number <= 0 ? '' : (number + 1).to_s
+    end
+
+    attr_reader :parallel_processes, :runner, :worker_env_var
+
+    attr_accessor :timeout,
+      :baseline_timeout,
+      :mutation_types,
+      :reporters,
+      :output_dir,
+      :minimum_score,
+      :fail_on_threshold,
+      :verbose,
+      :show_file_path,
+      :show_progress,
+      :test_selection,
+      :fail_fast
+
+    def initialize
+      self.parallel_processes = ENV['MUTATION_TESTER_PARALLEL_PROCESSES'] || self.class.auto_parallel_processes
+      self.runner = ENV['MUTATION_TESTER_RUNNER'] || :auto
+      self.worker_env_var = ENV['MUTATION_TESTER_WORKER_ENV']
+      @timeout = 30
+      @baseline_timeout = 300
+      @mutation_types = {
+        arithmetic: true,
+        comparison: true,
+        logical: true,
+        boolean: true,
+        number: true,
+        string: true,
+        conditional: true,
+        call_removal: true,
+        nil_injection: true,
+        argument: true,
+        strict_equality: false
+      }
+      @reporters = %i[console html json]
+      @output_dir = 'tmp/mutation_reports'
+      @minimum_score = 80.0
+      @fail_on_threshold = true
+      @verbose = false
+      @show_file_path = true
+      @show_progress = true
+      @test_selection = true
+      @fail_fast = false
+    end
+
+    def merge(options)
+      config = dup
+      options.each do |key, value|
+        config.public_send("#{key}=", value) if config.respond_to?("#{key}=")
+      end
+      config
+    end
+
+    def initialize_copy(source)
+      super
+      @mutation_types = source.mutation_types.dup
+      @reporters = source.reporters.dup
+    end
+
+    def parallel_processes=(value)
+      count = value.to_i
+      if count < 1
+        warn "[MutationTester] parallel_processes must be >= 1; got #{value.inspect}, falling back to 1 (serial execution)."
+        count = 1
+      end
+      @parallel_processes = count
+    end
+
+    def runner=(value)
+      mode = value.to_s.strip.downcase.to_sym
+      unless RUNNER_MODES.include?(mode)
+        warn "[MutationTester] runner must be one of #{RUNNER_MODES.join(", ")}; got #{value.inspect}, falling back to auto."
+        mode = :auto
+      end
+      @runner = mode
+    end
+
+    def worker_env_var=(value)
+      normalized = value.to_s.strip
+      @worker_env_var = normalized.empty? ? nil : normalized
+    end
+
+    def worker_env_assignment(index)
+      return nil unless @worker_env_var
+
+      { @worker_env_var => self.class.worker_env_value(index) }
+    end
+  end
+end

data/lib/mutation_tester/core.rb

@@ -0,0 +1,193 @@
+require_relative 'progress_display'
+
+module MutationTester
+  class Core
+    attr_reader :source_file, :spec_file, :mutations, :results, :config
+
+    def initialize(source_file, spec_file, config = MutationTester.configuration)
+      @source_file = File.expand_path(source_file)
+      @spec_file = File.expand_path(spec_file)
+      @config = config
+      @mutations = []
+      @results = []
+      @parse_failed = false
+      MutationRunner.recover_in_place_backup(@source_file)
+      @original_content = File.read(@source_file)
+    end
+
+    def run
+      print_header
+      return false unless run_original_tests
+
+      generate_mutations
+      return false if @parse_failed
+
+      if @mutations.empty?
+        puts Rainbow("\n✓ No mutations were generated for this file; nothing to test.").green
+        return true
+      end
+
+      return false unless shadow_environment_reliable?
+
+      run_mutations
+      generate_reports
+      return report_interruption if interrupted?
+
+      check_threshold
+    ensure
+      @mutation_runner&.cleanup_shadow_workspaces
+      ForkRunner.shutdown_all
+    end
+
+    def interrupted?
+      @config.fail_fast &&
+        @results.size < @mutations.size &&
+        @results.any? { |result| result[:status] == :survived }
+    end
+
+    def mutation_score
+      Reporters::BaseReporter.score(@results)
+    end
+
+    def threshold_met?
+      return true unless @config.fail_on_threshold
+
+      mutation_score >= @config.minimum_score
+    end
+
+    private
+
+    def print_header
+      puts Rainbow('=' * 80).bright
+      puts Rainbow("🧬 MutationTester v#{MutationTester::VERSION}").bright.cyan
+      puts Rainbow('=' * 80).bright
+      puts "Source: #{@source_file}"
+      puts "Spec:   #{@spec_file}"
+      puts Rainbow('=' * 80).bright
+    end
+
+    def run_original_tests
+      puts Rainbow("\n🧪 Running original tests...").yellow
+      command = test_command
+      result = command.run(timeout: @config.baseline_timeout, capture: true)
+
+      if result.timed_out?
+        puts Rainbow("❌ Original tests exceeded the baseline deadline of #{@config.baseline_timeout}s and were terminated.").red
+        puts Rainbow('   Speed them up or raise config.baseline_timeout (nil disables the deadline).').red
+        return false
+      end
+
+      unless result.passed?
+        replay_baseline_output(result.output)
+        puts Rainbow('❌ Original tests are failing. Fix them first!').red
+        puts Rainbow("\nDebug: The following command failed:").yellow
+        puts Rainbow("  #{command.command}").cyan
+        return false
+      end
+      puts Rainbow('✓ Original tests passed').green
+      true
+    end
+
+    def replay_baseline_output(output)
+      return if output.nil? || output.strip.empty?
+
+      puts Rainbow("\n🔴 Original test output:").red
+      puts output
+    end
+
+    def generate_mutations
+      puts Rainbow("\n📝 Generating mutations...").yellow
+
+      ast = Parser::CurrentRuby.parse(@original_content)
+      mutator = Mutator.new(@source_file, @config)
+      @mutations = mutator.generate_mutations(ast)
+
+      puts Rainbow("✓ Generated #{@mutations.size} mutations").green
+    rescue Parser::SyntaxError => e
+      puts Rainbow("❌ Failed to parse source file: #{e.message}").red
+      @parse_failed = true
+      @mutations = []
+    end
+
+    def shadow_environment_reliable?
+      return true unless @config.parallel_processes > 1
+      return true if mutation_runner.in_memory_first?
+
+      puts Rainbow("\n🩺 Verifying the shadow workspace with the unmutated source...").yellow
+      if mutation_runner.shadow_baseline_passes?
+        puts Rainbow('✓ Shadow workspace verified with the unmutated source').green
+        return true
+      end
+
+      puts Rainbow('❌ The unmutated source fails inside the shadow workspace; the shadow environment is unreliable.').red
+      puts Rainbow('   Every mutant would falsely die there, so the run is aborted instead of reporting a misleading score.').red
+      false
+    end
+
+    def run_mutations
+      return if @mutations.empty?
+
+      puts Rainbow("\n🔬 Running mutations in #{@config.parallel_processes} parallel job#{"s" if @config.parallel_processes > 1}...").yellow
+
+      progress_display = ProgressDisplay.new(@mutations.size, @config)
+
+      @results = mutation_runner.run(@mutations) do |mutation, index|
+        progress_display.update(mutation, index)
+      end
+
+      progress_display.finish
+      puts Rainbow("✓ Completed #{@results.size} mutations").green
+    end
+
+    def mutation_runner
+      @mutation_runner ||= MutationRunner.new(@source_file, @spec_file, @original_content, @config)
+    end
+
+    def generate_reports
+      puts Rainbow("\n📊 Generating reports...").yellow
+      FileUtils.mkdir_p(@config.output_dir)
+
+      @config.reporters.each do |reporter_type|
+        reporter = create_reporter(reporter_type)
+        reporter.generate if reporter
+      end
+    end
+
+    def create_reporter(type)
+      case type
+      when :console
+        Reporters::ConsoleReporter.new(@results, @source_file, @spec_file, @config, interrupted: interrupted?)
+      when :html
+        Reporters::HtmlReporter.new(@results, @source_file, @spec_file, @config, interrupted: interrupted?)
+      when :json
+        Reporters::JsonReporter.new(@results, @source_file, @spec_file, @config, interrupted: interrupted?)
+      end
+    end
+
+    def test_command
+      TestCommand.new(
+        @spec_file,
+        use_bundle_exec: TestCommand.use_bundle_exec?(@source_file),
+        runner: @config.runner
+      )
+    end
+
+    def report_interruption
+      puts Rainbow("\n🛑 Run interrupted by --fail-fast: a mutant survived after #{@results.size} of #{@mutations.size} mutations.").red
+      puts Rainbow('   Reports contain the results obtained up to the interruption.').red
+      false
+    end
+
+    def check_threshold
+      score = mutation_score
+
+      unless threshold_met?
+        puts Rainbow("\n❌ Mutation score #{score}% is below threshold #{@config.minimum_score}%").red
+        return false
+      end
+
+      puts Rainbow("\n✓ Mutation score: #{score}%").green
+      true
+    end
+  end
+end

data/lib/mutation_tester/fork_runner/worker.rb

@@ -0,0 +1,202 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'rspec/core'
+require_relative '../in_memory_loader'
+
+control = $stdout.dup
+control.sync = true
+STDOUT.reopen(File::NULL)
+
+kill_group = lambda do |pid|
+  begin
+    Process.kill('KILL', -pid)
+  rescue Errno::ESRCH, Errno::EPERM
+  end
+end
+
+monotonic = lambda { Process.clock_gettime(Process::CLOCK_MONOTONIC) }
+
+current_child = nil
+preloaded = nil
+
+%w[TERM INT].each do |signal|
+  trap(signal) do
+    kill_group.call(current_child) if current_child
+    trap(signal, 'DEFAULT')
+    Process.kill(signal, Process.pid)
+  end
+end
+
+supervise_child = lambda do |job, out, child_body|
+  result_reader, result_writer = IO.pipe
+
+  child = fork do
+    trap('TERM', 'DEFAULT')
+    trap('INT', 'DEFAULT')
+    out.close
+    result_reader.close
+    begin
+      Process.setpgid(0, 0)
+    rescue Errno::EACCES, Errno::EPERM
+    end
+    Dir.chdir(job['chdir']) if job['chdir']
+    sink = File.open(job['log'] || File::NULL, 'w')
+    sink.sync = true
+    STDOUT.reopen(sink)
+    STDERR.reopen(sink)
+    result_writer.puts(child_body.call)
+    result_writer.close
+  end
+
+  result_writer.close
+  begin
+    Process.setpgid(child, child)
+  rescue Errno::EACCES, Errno::EPERM, Errno::ESRCH
+  end
+  current_child = child
+  out.puts(JSON.generate('event' => 'started', 'pid' => child))
+
+  deadline = job['timeout'] ? monotonic.call + job['timeout'] : nil
+  reaped = nil
+  timed_out = false
+  payload_ready = false
+
+  loop do
+    _pid, reaped = Process.waitpid2(child, Process::WNOHANG)
+    break if reaped
+
+    if deadline && monotonic.call >= deadline
+      timed_out = true
+      kill_group.call(child)
+      begin
+        Process.waitpid(child)
+      rescue Errno::ECHILD
+      end
+      break
+    end
+
+    if payload_ready
+      sleep(0.002)
+    else
+      remaining = deadline ? deadline - monotonic.call : nil
+      wait = remaining ? remaining.clamp(0, 0.05) : 0.05
+      payload_ready = !IO.select([result_reader], nil, nil, wait).nil?
+    end
+  end
+
+  current_child = nil
+  payload = result_reader.read
+  result_reader.close
+  [timed_out, payload, reaped]
+end
+
+run_job = lambda do |job, out|
+  timed_out, payload, reaped = supervise_child.call(job, out, lambda do
+    RSpec::Core::Runner.run([job['spec'], *Array(job['args'])], STDERR, STDOUT).to_i
+  end)
+
+  status =
+    if timed_out
+      'timeout'
+    elsif payload[/-?\d+/] == '0' && reaped.success?
+      'pass'
+    else
+      'fail'
+    end
+
+  out.puts(JSON.generate('event' => 'result', 'status' => status))
+end
+
+preload_specs = lambda do |request, out|
+  begin
+    Dir.chdir(request['chdir']) if request['chdir']
+    sink = File.open(File::NULL, 'w')
+    runner = RSpec::Core::Runner.new(RSpec::Core::ConfigurationOptions.new([request['spec']]))
+    runner.setup(sink, sink)
+    preloaded = runner
+    out.puts(JSON.generate('event' => 'preloaded', 'status' => 'ok'))
+  rescue ScriptError, StandardError => e
+    out.puts(JSON.generate('event' => 'preloaded', 'status' => 'error', 'message' => "#{e.class}: #{e.message}"))
+  end
+end
+
+run_in_memory_job = lambda do |job, out|
+  request = job['in_memory']
+
+  unless preloaded
+    out.puts(JSON.generate('event' => 'result', 'status' => 'error', 'message' => 'the worker has no preloaded spec environment'))
+    next
+  end
+
+  timed_out, payload, reaped = supervise_child.call(job, out, lambda do
+    begin
+      MutationTester::InMemoryLoader.apply(request['source'], request['path'])
+      JSON.generate('code' => preloaded.run_specs(RSpec.world.ordered_example_groups).to_i)
+    rescue ScriptError, StandardError => e
+      JSON.generate('error' => "#{e.class}: #{e.message}")
+    end
+  end)
+
+  outcome = begin
+    JSON.parse(payload)
+  rescue JSON::ParserError
+    nil
+  end
+
+  event =
+    if timed_out
+      { 'event' => 'result', 'status' => 'timeout' }
+    elsif outcome.is_a?(Hash) && outcome['error']
+      { 'event' => 'result', 'status' => 'error', 'message' => outcome['error'] }
+    elsif outcome.is_a?(Hash) && outcome['code'] == 0 && reaped.success?
+      { 'event' => 'result', 'status' => 'pass' }
+    else
+      { 'event' => 'result', 'status' => 'fail' }
+    end
+
+  out.puts(JSON.generate(event))
+end
+
+serve = nil
+
+spawn_clone = lambda do |request, out|
+  child = fork do
+    guard = Thread.new do
+      sleep 15
+      Process.kill('KILL', Process.pid)
+    end
+    begin
+      Process.setpgid(0, 0)
+    rescue Errno::EACCES, Errno::EPERM
+    end
+    input = File.open(request['job'], 'r')
+    clone_out = File.open(request['events'], 'w')
+    guard.kill
+    clone_out.sync = true
+    out.close
+    STDIN.reopen(File::NULL)
+    request['env']&.each { |name, value| ENV[name] = value }
+    serve.call(input, clone_out)
+  end
+  Process.detach(child)
+  out.puts(JSON.generate('event' => 'cloned', 'pid' => child))
+end
+
+serve = lambda do |input, out|
+  out.puts(JSON.generate('event' => 'ready'))
+  input.each_line do |line|
+    job = JSON.parse(line)
+    if job['clone']
+      spawn_clone.call(job['clone'], out)
+    elsif job['preload']
+      preload_specs.call(job['preload'], out)
+    elsif job['in_memory']
+      run_in_memory_job.call(job, out)
+    else
+      run_job.call(job, out)
+    end
+  end
+end
+
+serve.call($stdin, control)