henitai 0.1.1 → 0.1.3

data/lib/henitai/equivalence_detector.rb

@@ -10,7 +10,7 @@ module Henitai
   # obvious enough to be useful.
   class EquivalenceDetector
     def analyze(mutant)
-      return mutant unless equivalent_arithmetic_mutation?(mutant)
+      return mutant unless equivalent_mutation?(mutant)
 
       mutant.status = :equivalent
       mutant
@@ -18,6 +18,10 @@ module Henitai
 
     private
 
+    def equivalent_mutation?(mutant)
+      equivalent_arithmetic_mutation?(mutant) || equivalent_logical_mutation?(mutant)
+    end
+
     def equivalent_arithmetic_mutation?(mutant)
       original = mutant.original_node
       mutated = mutant.mutated_node
@@ -50,6 +54,61 @@ module Henitai
         one_operand?(mutated)
     end
 
+    def equivalent_logical_mutation?(mutant)
+      original = mutant.original_node
+      mutated = mutant.mutated_node
+      return false unless logical_node?(original)
+
+      logical_identity_equivalent?(original, mutated)
+    end
+
+    def logical_node?(node)
+      node.is_a?(Parser::AST::Node) && %i[and or].include?(node.type)
+    end
+
+    def logical_identity_equivalent?(original, mutated)
+      case original.type
+      when :or
+        false_identity_equivalent?(original, mutated)
+      when :and
+        true_identity_equivalent?(original, mutated)
+      else
+        false
+      end
+    end
+
+    def false_identity_equivalent?(original, mutated)
+      return true if false_operand?(original.children[0]) && same_node?(mutated, original.children[1])
+      return true if false_operand?(original.children[1]) && same_node?(mutated, original.children[0])
+
+      false
+    end
+
+    def true_identity_equivalent?(original, mutated)
+      return true if true_operand?(original.children[0]) && same_node?(mutated, original.children[1])
+      return true if true_operand?(original.children[1]) && same_node?(mutated, original.children[0])
+
+      false
+    end
+
+    def false_operand?(node)
+      # Parser uses :true / :false node types, so the AST symbols are intentional.
+      # rubocop:disable Lint/BooleanSymbol
+      boolean_literal?(node, :false)
+      # rubocop:enable Lint/BooleanSymbol
+    end
+
+    def true_operand?(node)
+      # Parser uses :true / :false node types, so the AST symbols are intentional.
+      # rubocop:disable Lint/BooleanSymbol
+      boolean_literal?(node, :true)
+      # rubocop:enable Lint/BooleanSymbol
+    end
+
+    def boolean_literal?(node, type)
+      node.is_a?(Parser::AST::Node) && node.type == type && node.children.empty?
+    end
+
     def additive_operator?(operator)
       %i[+ -].include?(operator)
     end

data/lib/henitai/execution_engine.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require "etc"
+require_relative "parallel_execution_runner"
 
 module Henitai
   # Runs pending mutants through the selected integration.
@@ -12,7 +12,7 @@ module Henitai
           pending_mutants = Array(mutants).select(&:pending?)
           mutex = Mutex.new
           if parallel_execution?(config, pending_mutants)
-            run_parallel(pending_mutants, integration, config, progress_reporter, mutex)
+            run_parallel(pending_mutants, integration, config, progress_reporter)
           else
             run_linear(pending_mutants, integration, config, progress_reporter, mutex)
           end
@@ -31,7 +31,12 @@ module Henitai
 
     def worker_count(config)
       configured_jobs = config.respond_to?(:jobs) ? config.jobs : nil
-      configured_jobs || Etc.nprocessors
+      return configured_jobs if configured_jobs
+
+      # The fallback stays conservative for now; the execution policy still
+      # defaults to a single worker even though AvailableCpuCount exists as a
+      # future policy hook.
+      1
     end
 
     def run_linear(mutants, integration, config, progress_reporter, mutex)
@@ -40,24 +45,29 @@ module Henitai
       end
     end
 
-    def run_parallel(mutants, integration, config, progress_reporter, mutex)
-      queue = Queue.new
-      mutants.each { |mutant| queue << mutant }
+    def run_parallel(mutants, integration, config, progress_reporter)
+      ParallelExecutionRunner.new(
+        worker_count: worker_count(config)
+      ).run(
+        mutants,
+        integration,
+        config,
+        progress_reporter,
+        stdin_pipe: pipe_stdin?,
+        process_mutant: method(:process_mutant)
+      )
+    end
 
-      Array.new(worker_count(config)) do
-        Thread.new do
-          loop do
-            mutant = queue.pop(true)
-            process_mutant(mutant, integration, config, progress_reporter, mutex)
-          rescue ThreadError
-            break
-          end
-        end
-      end.each(&:join)
+    def pipe_stdin?
+      $stdin.stat.pipe?
+    rescue Errno::EBADF
+      false
     end
 
     def process_mutant(mutant, integration, config, progress_reporter, mutex)
       test_files = prioritized_tests_for(mutant, integration, config)
+      mutant.covered_by = test_files if mutant.respond_to?(:covered_by=)
+      mutant.tests_completed = test_files.size if mutant.respond_to?(:tests_completed=)
       scenario_result = run_with_flaky_retry(mutant, integration, config, test_files, mutex)
       mutant.status = scenario_status(scenario_result)
 
@@ -69,16 +79,18 @@ module Henitai
     end
 
     def prioritized_tests_for(mutant, integration, config)
-      test_prioritizer.sort(
-        integration.select_tests(mutant.subject),
+      tests = integration.select_tests(mutant.subject)
+      tests = per_test_coverage_selector.filter(
+        tests,
         mutant,
-        test_history(config)
+        reports_dir: config.reports_dir
       )
+      test_prioritizer.sort(tests, mutant, test_history(config))
     end
 
-    def test_prioritizer
-      @test_prioritizer ||= TestPrioritizer.new
-    end
+    def test_prioritizer = @test_prioritizer ||= TestPrioritizer.new
+
+    def per_test_coverage_selector = @per_test_coverage_selector ||= PerTestCoverageSelector.new
 
     def test_history(config)
       return {} unless config.respond_to?(:history)

data/lib/henitai/integration/rspec_process_runner.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Henitai
+  module Integration
+    # Runs RSpec child and suite processes on behalf of the integration.
+    class RspecProcessRunner
+      def run_mutant(integration, mutant:, test_files:, timeout:)
+        log_paths = integration.scenario_log_paths(mutant_log_name(mutant))
+        pid = fork_mutant_process(integration, mutant, test_files, log_paths)
+        wait_result = integration.wait_with_timeout(pid, timeout)
+        integration.build_result(wait_result, log_paths)
+      ensure
+        finalize_mutant_run(integration, pid, wait_result)
+      end
+
+      def run_suite(integration, test_files, timeout:)
+        log_paths = integration.scenario_log_paths("baseline")
+        wait_result = nil
+        FileUtils.mkdir_p(File.dirname(log_paths[:stdout_path]))
+        pid = integration.spawn_suite_process(test_files, log_paths)
+        wait_result = integration.wait_with_timeout(pid, timeout)
+        integration.build_result(wait_result, log_paths)
+      ensure
+        if pid
+          integration.cleanup_process_group(pid) unless wait_result == :timeout
+          integration.reap_child(pid) if wait_result.nil?
+        end
+      end
+
+      private
+
+      def fork_mutant_process(integration, mutant, test_files, log_paths)
+        Process.fork do
+          Process.setpgid(0, 0)
+          ENV["HENITAI_MUTANT_ID"] = mutant.id
+          Process.exit(
+            integration.run_in_child(
+              mutant: mutant,
+              test_files: test_files,
+              log_paths: log_paths
+            )
+          )
+        end
+      end
+
+      def finalize_mutant_run(integration, pid, wait_result)
+        return unless pid
+
+        integration.cleanup_process_group(pid) unless wait_result == :timeout
+        integration.reap_child(pid) if wait_result.nil?
+      end
+
+      def mutant_log_name(mutant)
+        "mutant-#{mutant.id}"
+      end
+    end
+  end
+end

data/lib/henitai/integration.rb

@@ -2,6 +2,7 @@
 
 require "fileutils"
 require "minitest"
+require_relative "integration/rspec_process_runner"
 
 module Henitai
   # Namespace for test-framework integrations.
@@ -56,8 +57,8 @@ module Henitai
 
       def build_child_output_files(log_paths)
         {
-          original_stdout: $stdout.dup,
-          original_stderr: $stderr.dup,
+          original_stdout: stdout_stream.dup,
+          original_stderr: stderr_stream.dup,
           stdout_file: File.new(log_paths[:stdout_path], "w"),
           stderr_file: File.new(log_paths[:stderr_path], "w")
         }
@@ -69,13 +70,17 @@ module Henitai
       end
 
       def redirect_child_output(output_files)
-        $stdout.reopen(output_files[:stdout_file])
-        $stderr.reopen(output_files[:stderr_file])
+        reopen_child_output_stream(stdout_stream, output_files[:stdout_file])
+        reopen_child_output_stream(stderr_stream, output_files[:stderr_file])
+        $stdout = stdout_stream
+        $stderr = stderr_stream
       end
 
       def restore_child_output(output_files)
-        reopen_child_output_stream($stdout, output_files[:original_stdout])
-        reopen_child_output_stream($stderr, output_files[:original_stderr])
+        reopen_child_output_stream(stdout_stream, output_files[:original_stdout])
+        reopen_child_output_stream(stderr_stream, output_files[:original_stderr])
+        $stdout = output_files[:original_stdout]
+        $stderr = output_files[:original_stderr]
       end
 
       def reopen_child_output_stream(stream, original_stream)
@@ -94,6 +99,14 @@ module Henitai
         reports_dir = ENV.fetch("HENITAI_REPORTS_DIR", "reports")
         File.join(reports_dir, "mutation-coverage", mutant_id.to_s)
       end
+
+      def stdout_stream
+        @stdout_stream ||= IO.for_fd(1)
+      end
+
+      def stderr_stream
+        @stderr_stream ||= IO.for_fd(2)
+      end
     end
 
     # Integration adapter for RSpec.
@@ -105,7 +118,12 @@ module Henitai
     def self.for(name)
       const_get(name.capitalize)
     rescue NameError
-      raise ArgumentError, "Unknown integration: #{name}. Available: rspec"
+      available = constants.filter_map do |constant_name|
+        integration = const_get(constant_name)
+        constant_name.to_s.downcase if integration.is_a?(Class) && integration < Base
+      end.sort.join(", ")
+
+      raise ArgumentError, "Unknown integration: #{name}. Available: #{available}"
     end
 
     # Base class for all integrations.
@@ -130,6 +148,100 @@ module Henitai
       def run_mutant(mutant:, test_files:, timeout:)
         raise NotImplementedError
       end
+
+      def per_test_coverage_supported?
+        false
+      end
+
+      def wait_with_timeout(pid, timeout)
+        deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout
+
+        loop do
+          wait_result = Process.wait(pid, Process::WNOHANG)
+          return Process.last_status if wait_result
+
+          if Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
+            final_wait_result = Process.wait(pid, Process::WNOHANG)
+            return Process.last_status if final_wait_result
+
+            return handle_timeout(pid)
+          end
+
+          pause(0.01)
+        end
+      end
+
+      def reap_child(pid)
+        Process.wait(pid)
+      rescue Errno::ECHILD, Errno::ESRCH
+        nil
+      end
+
+      def cleanup_process_group(pid)
+        Process.kill(:SIGTERM, -pid)
+        pause(2.0)
+        Process.kill(:SIGKILL, -pid)
+      rescue Errno::EPERM
+        cleanup_child_process(pid)
+      rescue Errno::ESRCH
+        nil
+      end
+
+      private
+
+      def pause(seconds)
+        sleep(seconds)
+      end
+
+      def handle_timeout(pid)
+        begin
+          cleanup_process_group(pid)
+        ensure
+          reap_child(pid)
+        end
+        :timeout
+      end
+
+      def cleanup_child_process(pid)
+        Process.kill(:SIGTERM, pid)
+        pause(2.0)
+        Process.kill(:SIGKILL, pid)
+      rescue Errno::EPERM, Errno::ESRCH
+        nil
+      end
+
+      def rspec_options
+        []
+      end
+
+      def subprocess_env
+        { "PARALLEL_WORKERS" => "1" }
+      end
+
+      def scenario_log_support
+        @scenario_log_support ||= ScenarioLogSupport.new
+      end
+
+      def with_subprocess_env
+        original_env = {} # : Hash[String, String?]
+        subprocess_env.each do |key, value|
+          original_env[key] = ENV.fetch(key, nil)
+          ENV[key] = value
+        end
+        yield
+      ensure
+        restore_subprocess_env(original_env)
+      end
+
+      def restore_subprocess_env(original_env)
+        original_env.each do |key, value|
+          if value.nil?
+            ENV.delete(key)
+          else
+            ENV[key] = value
+          end
+        end
+      end
     end
 
     # RSpec integration adapter.
@@ -162,64 +274,25 @@ module Henitai
       end
 
       def run_mutant(mutant:, test_files:, timeout:)
-        log_paths = scenario_log_paths("mutant-#{mutant.id}")
-        pid = Process.fork do
-          ENV["HENITAI_MUTANT_ID"] = mutant.id
-          Process.exit(run_in_child(mutant:, test_files:, log_paths:))
-        end
-
-        build_result(wait_with_timeout(pid, timeout), log_paths)
+        RspecProcessRunner.new.run_mutant(self, mutant:, test_files:, timeout:)
       end
 
-      def run_suite(test_files, timeout: DEFAULT_SUITE_TIMEOUT)
-        log_paths = scenario_log_paths("baseline")
-        FileUtils.mkdir_p(File.dirname(log_paths[:stdout_path]))
-        pid = File.open(log_paths[:stdout_path], "w") do |stdout_file|
-          File.open(log_paths[:stderr_path], "w") do |stderr_file|
-            Process.spawn(*suite_command(test_files), out: stdout_file, err: stderr_file)
-          end
-        end
-        build_result(wait_with_timeout(pid, timeout), log_paths)
+      def per_test_coverage_supported?
+        true
       end
 
-      private
-
-      def run_in_child(mutant:, test_files:, log_paths:)
-        scenario_log_support.with_coverage_dir(mutant.id) do
-          scenario_log_support.capture_child_output(log_paths) do
-            return 2 if Mutant::Activator.activate!(mutant) == :compile_error
-
-            run_tests(test_files)
-          end
-        end
+      def run_suite(test_files, timeout: DEFAULT_SUITE_TIMEOUT)
+        RspecProcessRunner.new.run_suite(self, test_files, timeout:)
       end
 
       def suite_command(test_files)
-        ["bundle", "exec", "rspec", *test_files]
-      end
-
-      def wait_with_timeout(pid, timeout)
-        deadline = Process.clock_gettime(Process::CLOCK_MONOTONIC) + timeout
-
-        loop do
-          return Process.last_status if Process.wait(pid, Process::WNOHANG)
-          return handle_timeout(pid) if Process.clock_gettime(Process::CLOCK_MONOTONIC) >= deadline
-
-          pause(0.01)
-        end
-      end
-
-      def handle_timeout(pid)
-        begin
-          Process.kill(:SIGTERM, pid)
-          pause(2.0)
-          Process.kill(:SIGKILL, pid)
-        rescue Errno::ESRCH
-          # The child may exit after SIGTERM but before SIGKILL.
-        ensure
-          reap_child(pid)
-        end
-        :timeout
+        [
+          "bundle", "exec", "ruby",
+          "-r", "henitai/rspec_coverage_formatter",
+          "-S", "rspec", *test_files,
+          "--format", "progress",
+          "--format", "Henitai::CoverageFormatter"
+        ]
       end
 
       def run_tests(test_files)
@@ -230,36 +303,6 @@ module Henitai
         status == true ? 0 : 1
       end
 
-      def rspec_options
-        ["--require", "henitai/coverage_formatter"]
-      end
-
-      def pause(seconds)
-        sleep(seconds)
-      end
-
-      def scenario_log_support
-        @scenario_log_support ||= ScenarioLogSupport.new
-      end
-
-      def read_log_file(path)
-        return "" unless File.exist?(path)
-
-        File.read(path)
-      end
-
-      def write_combined_log(path, stdout, stderr)
-        FileUtils.mkdir_p(File.dirname(path))
-        File.write(path, combined_log(stdout, stderr))
-      end
-
-      def combined_log(stdout, stderr)
-        [
-          (stdout.empty? ? nil : "stdout:\n#{stdout}"),
-          (stderr.empty? ? nil : "stderr:\n#{stderr}")
-        ].compact.join("\n")
-      end
-
       def scenario_log_paths(name)
         reports_dir = ENV.fetch("HENITAI_REPORTS_DIR", "reports")
         log_dir = File.join(reports_dir, "mutation-logs")
@@ -378,10 +421,70 @@ module Henitai
         ].uniq
       end
 
-      def reap_child(pid)
-        Process.wait(pid)
-      rescue Errno::ECHILD, Errno::ESRCH
-        nil
+      def spawn_suite_process(test_files, log_paths)
+        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_command(test_files),
+              out: stdout_file,
+              err: stderr_file,
+              pgroup: true
+            )
+          end
+        end
+      end
+
+      def run_in_child(mutant:, test_files:, log_paths:)
+        Thread.report_on_exception = false
+        with_subprocess_env do
+          scenario_log_support.with_coverage_dir(mutant.id) do
+            scenario_log_support.capture_child_output(log_paths) do
+              return 2 if Mutant::Activator.activate!(mutant) == :compile_error
+
+              run_tests(test_files)
+            end
+          end
+        end
+      end
+
+      def read_log_file(path)
+        return "" unless File.exist?(path)
+
+        File.read(path)
+      end
+
+      def write_combined_log(path, stdout, stderr)
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, combined_log(stdout, stderr))
+      end
+
+      def combined_log(stdout, stderr)
+        [
+          (stdout.empty? ? nil : "stdout:\n#{stdout}"),
+          (stderr.empty? ? nil : "stderr:\n#{stderr}")
+        ].compact.join("\n")
+      end
+    end
+
+    # Stores the child-process log helpers shared by the integration specs.
+    class ScenarioLogSupport
+      def read_log_file(path)
+        return "" unless File.exist?(path)
+
+        File.read(path)
+      end
+
+      def write_combined_log(path, stdout, stderr)
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, combined_log(stdout, stderr))
+      end
+
+      def combined_log(stdout, stderr)
+        [
+          (stdout.empty? ? nil : "stdout:\n#{stdout}"),
+          (stderr.empty? ? nil : "stderr:\n#{stderr}")
+        ].compact.join("\n")
       end
     end
 
@@ -404,13 +507,11 @@ module Henitai
 
       def run_suite(test_files, timeout: DEFAULT_SUITE_TIMEOUT)
         log_paths = scenario_log_paths("baseline")
-        FileUtils.mkdir_p(File.dirname(log_paths[:stdout_path]))
-        pid = 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_command(test_files), out: stdout_file, err: stderr_file)
-          end
-        end
-        build_result(wait_with_timeout(pid, timeout), log_paths)
+        pid = spawn_suite_process(test_files, log_paths)
+        wait_result = wait_with_timeout(pid, timeout)
+        build_result(wait_result, log_paths)
+      ensure
+        cleanup_suite_process(pid, wait_result)
       end
 
       private
@@ -443,12 +544,33 @@ module Henitai
       end
 
       def subprocess_env
-        env = {} # : Hash[String, String]
+        env = super
         env["RAILS_ENV"] = "test" unless ENV["RAILS_ENV"] == "test"
         env["PARALLEL_WORKERS"] = "1"
         env
       end
 
+      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_command(test_files),
+              out: stdout_file,
+              err: stderr_file
+            )
+          end
+        end
+      end
+
+      def cleanup_suite_process(pid, wait_result)
+        return unless pid
+
+        cleanup_child_process(pid)
+        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/") }

data/lib/henitai/minitest_simplecov.rb

@@ -6,6 +6,9 @@
 # Must be required before any application code is loaded so that Coverage
 # tracking is active from the first line.
 
+require "coverage"
+Coverage.start(lines: true, branches: true, methods: true)
+
 require "simplecov"
 
 SimpleCov.coverage_dir(ENV.fetch("HENITAI_COVERAGE_DIR", "coverage"))