henitai 0.1.2 → 0.1.4

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.
@@ -148,11 +149,99 @@ module Henitai
         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.
@@ -185,65 +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:)
-        Thread.report_on_exception = false
-        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)
@@ -254,32 +303,6 @@ module Henitai
         status == true ? 0 : 1
       end
 
-      def rspec_options
-        ["--require", "henitai/rspec_coverage_formatter"]
-      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")
@@ -291,35 +314,18 @@ module Henitai
       end
 
       def build_result(wait_result, log_paths)
-        status = scenario_status(wait_result)
         stdout = read_log_file(log_paths[:stdout_path])
         stderr = read_log_file(log_paths[:stderr_path])
         write_combined_log(log_paths[:log_path], stdout, stderr)
 
-        ScenarioExecutionResult.new(
-          status:,
+        ScenarioExecutionResult.build(
+          wait_result:,
           stdout:,
           stderr:,
-          log_path: log_paths[:log_path],
-          exit_status: exit_status_for(wait_result)
+          log_path: log_paths[:log_path]
         )
       end
 
-      def scenario_status(wait_result)
-        return :timeout if wait_result == :timeout
-        return :compile_error if exit_status_for(wait_result) == 2
-        return :survived if wait_result.respond_to?(:success?) && wait_result.success?
-
-        :killed
-      end
-
-      def exit_status_for(wait_result)
-        return nil if wait_result == :timeout
-        return nil unless wait_result.respond_to?(:exitstatus)
-
-        wait_result.exitstatus
-      end
-
       def spec_files
         Dir.glob("spec/**/*_spec.rb")
       end
@@ -398,10 +404,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
 
@@ -424,13 +490,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
@@ -463,12 +527,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/mutant.rb

@@ -35,7 +35,7 @@ module Henitai
 
     attr_reader :id, :subject, :operator, :original_node, :mutated_node,
                 :mutation_type, :description, :location
-    attr_accessor :status, :killing_test, :duration
+    attr_accessor :status, :killing_test, :duration, :covered_by, :tests_completed
 
     # @param subject [Subject] the subject being mutated
     # @param operator [Symbol] operator name, e.g. :ArithmeticOperator
@@ -53,6 +53,8 @@ module Henitai
       @status        = :pending
       @killing_test  = nil
       @duration      = nil
+      @covered_by    = nil
+      @tests_completed = nil
     end
 
     def killed?      = @status == :killed