henitai 0.1.10 → 0.2.1

data/lib/henitai/integration.rb

@@ -1,7 +1,16 @@
 # frozen_string_literal: true
 
 require "fileutils"
+require "stringio"
+require_relative "process_wakeup"
 require_relative "integration/rspec_process_runner"
+require_relative "integration/scenario_log_support"
+require_relative "integration/coverage_suppression"
+require_relative "integration/child_debug_support"
+require_relative "integration/base"
+require_relative "integration/mutant_run_support"
+require_relative "integration/rspec_child_runner"
+require_relative "integration/rspec_test_selection"
 
 module Henitai
   # Namespace for test-framework integrations.
@@ -18,96 +27,6 @@ module Henitai
   # Built-in integrations:
   #   rspec  — RSpec 3.x
   module Integration
-    # Shared helpers for capturing stdout/stderr from child test processes.
-    class ScenarioLogSupport
-      def capture_child_output(log_paths)
-        output_files = open_child_output(log_paths)
-        yield
-      ensure
-        close_child_output(output_files)
-      end
-
-      def with_coverage_dir(mutant_id)
-        original_coverage_dir = ENV.fetch("HENITAI_COVERAGE_DIR", nil)
-        ENV["HENITAI_COVERAGE_DIR"] = mutation_coverage_dir(mutant_id)
-        yield
-      ensure
-        if original_coverage_dir.nil?
-          ENV.delete("HENITAI_COVERAGE_DIR")
-        else
-          ENV["HENITAI_COVERAGE_DIR"] = original_coverage_dir
-        end
-      end
-
-      def open_child_output(log_paths)
-        FileUtils.mkdir_p(File.dirname(log_paths[:log_path]))
-        output_files = build_child_output_files(log_paths)
-        sync_child_output_files(output_files)
-        redirect_child_output(output_files)
-        output_files
-      end
-
-      def close_child_output(output_files)
-        return unless output_files
-
-        restore_child_output(output_files)
-        close_child_output_files(output_files)
-      end
-
-      def build_child_output_files(log_paths)
-        {
-          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")
-        }
-      end
-
-      def sync_child_output_files(output_files)
-        output_files[:stdout_file].sync = true
-        output_files[:stderr_file].sync = true
-      end
-
-      def redirect_child_output(output_files)
-        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_stream, output_files[:original_stdout])
-        reopen_child_output_stream(stderr_stream, output_files[:original_stderr])
-        $stdout = stdout_stream
-        $stderr = stderr_stream
-      end
-
-      def reopen_child_output_stream(stream, original_stream)
-        stream.reopen(original_stream) if original_stream
-      end
-
-      def close_child_output_files(output_files)
-        %i[stdout_file stderr_file original_stdout original_stderr].each do |key|
-          output_files[key]&.close
-        end
-      end
-
-      private
-
-      def mutation_coverage_dir(mutant_id)
-        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.
     #
     # This class exists as the stable public entry point for the RSpec
@@ -125,156 +44,15 @@ module Henitai
       raise ArgumentError, "Unknown integration: #{name}. Available: #{available}"
     end
 
-    # Base class for all integrations.
-    class Base
-      # @param subject [Subject]
-      # @return [Array<String>] paths to test files that cover this subject
-      def select_tests(subject)
-        raise NotImplementedError
-      end
-
-      # @return [Array<String>] all test files for the configured framework
-      def test_files
-        raise NotImplementedError
-      end
-
-      # Run test files in a child process with the mutant active.
-      #
-      # @param mutant [Mutant]
-      # @param test_files [Array<String>]
-      # @param timeout [Float] seconds
-      # @return [ScenarioExecutionResult]
-      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.
     class Rspec < Base
-      DEFAULT_SUITE_TIMEOUT = 300.0
-      REQUIRE_DIRECTIVE_PATTERN = /
-        \A\s*
-        (require|require_relative)
-        \s*
-        (?:\(\s*)?
-        ["']([^"']+)["']
-        \s*\)?
-      /x
+      include MutantRunSupport
+      include RspecChildRunner
+      include RspecTestSelection
 
-      def select_tests(subject)
-        matches = spec_files.select do |path|
-          content = File.read(path)
-          selection_patterns(subject).any? { |pattern| content.include?(pattern) }
-        rescue StandardError
-          false
-        end
-
-        return matches unless matches.empty?
-
-        fallback_spec_files(subject)
-      end
+      DEFAULT_SUITE_TIMEOUT = 300.0
 
-      def test_files
-        spec_files
-      end
-
-      def run_mutant(mutant:, test_files:, timeout:)
-        RspecProcessRunner.new.run_mutant(self, mutant:, test_files:, timeout:)
-      end
+      def test_files = spec_files
 
       def per_test_coverage_supported?
         true
@@ -288,140 +66,30 @@ module Henitai
         [
           "bundle", "exec", "ruby",
           "-r", "henitai/rspec_coverage_formatter",
-          "-S", "rspec", *test_files,
-          "--format", "progress",
-          "--format", "Henitai::CoverageFormatter"
+          "-e", rspec_suite_runner_script,
+          *test_files
         ]
       end
 
-      def run_tests(test_files)
-        require "rspec/core"
-        status = RSpec::Core::Runner.run(test_files + rspec_options)
-        return status if status.is_a?(Integer)
+      def rspec_suite_runner_script
+        <<~RUBY
+          require "rspec/core"
 
-        status == true ? 0 : 1
-      end
+          test_files = ARGV.map { |file| File.expand_path(file) }
+          config = RSpec.configuration
+          options = RSpec::Core::ConfigurationOptions.new(
+            ["--format", "progress", "--format", "Henitai::CoverageFormatter"]
+          )
+          runner = RSpec::Core::Runner.send(:new, options)
 
-      def scenario_log_paths(name)
-        reports_dir = ENV.fetch("HENITAI_REPORTS_DIR", "reports")
-        log_dir = File.join(reports_dir, "mutation-logs")
-        {
-          stdout_path: File.join(log_dir, "#{name}.stdout.log"),
-          stderr_path: File.join(log_dir, "#{name}.stderr.log"),
-          log_path: File.join(log_dir, "#{name}.log")
-        }
-      end
-
-      def build_result(wait_result, log_paths)
-        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.build(
-          wait_result:,
-          stdout:,
-          stderr:,
-          log_path: log_paths[:log_path]
-        )
-      end
-
-      def spec_files
-        paths = Dir.glob("spec/**/*_spec.rb")
-        paths - excluded_spec_files
-      end
+          RSpec::Core::Runner.send(:trap_interrupt)
+          runner.send(:configure, $stderr, $stdout)
+          config.files_to_run = test_files
+          config.load_spec_files
 
-      def fallback_spec_files(subject)
-        return [] unless subject.source_file
-
-        matches = spec_files.select do |path|
-          requires_source_file_transitively?(path, subject.source_file)
-        rescue StandardError
-          false
-        end
-
-        matches.empty? ? spec_files : matches
-      end
-
-      def excluded_spec_files
-        rspec_exclude_patterns.flat_map { |pattern| Dir.glob(pattern) }.uniq
-      end
-
-      def rspec_exclude_patterns
-        rspec_config_lines.filter_map do |line|
-          line[/\A--exclude-pattern\s+(.+)\z/, 1]
-        end
-      end
-
-      def rspec_config_lines
-        return [] unless File.exist?(rspec_config_path)
-
-        File.readlines(rspec_config_path, chomp: true).map(&:strip)
-      end
-
-      def rspec_config_path
-        ".rspec"
-      end
-
-      def selection_patterns(subject)
-        [
-          subject.expression,
-          subject.namespace
-        ].compact.uniq.sort_by(&:length).reverse
-      end
-
-      def requires_source_file?(spec_file, source_file)
-        content = File.read(spec_file)
-        basename = File.basename(source_file, ".rb")
-        content.include?(basename) || content.include?(source_file)
-      end
-
-      def requires_source_file_transitively?(spec_file, source_file, visited = [])
-        normalized_spec_file = File.expand_path(spec_file)
-        return false if visited.include?(normalized_spec_file)
-
-        visited << normalized_spec_file
-        return true if requires_source_file?(spec_file, source_file)
-
-        required_files(spec_file).any? do |required_file|
-          requires_source_file_transitively?(required_file, source_file, visited)
-        end
-      end
-
-      def required_files(spec_file)
-        File.read(spec_file).lines.filter_map do |line|
-          match = line.match(REQUIRE_DIRECTIVE_PATTERN)
-          next unless match
-
-          resolve_required_file(spec_file, match[1].to_s, match[2].to_s)
-        end
-      end
-
-      def resolve_required_file(spec_file, method_name, required_path)
-        candidates =
-          if method_name == "require_relative"
-            relative_candidates(spec_file, required_path)
-          else
-            require_candidates(spec_file, required_path)
-          end
-
-        candidates.find { |candidate| File.file?(candidate) }
-      end
-
-      def relative_candidates(spec_file, required_path)
-        expand_candidates(File.dirname(spec_file), required_path)
-      end
-
-      def require_candidates(spec_file, required_path)
-        ([File.dirname(spec_file), Dir.pwd] + $LOAD_PATH).flat_map do |base_path|
-          expand_candidates(base_path, required_path)
-        end
-      end
-
-      def expand_candidates(base_path, required_path)
-        [
-          File.expand_path(required_path, base_path),
-          File.expand_path("#{required_path}.rb", base_path)
-        ].uniq
+          status = runner.send(:run_specs, RSpec.world.ordered_example_groups)
+          exit(status.is_a?(Integer) ? status : (status == true ? 0 : 1))
+        RUBY
       end
 
       def spawn_suite_process(test_files, log_paths)
@@ -438,168 +106,24 @@ module Henitai
         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
-
-    # Prepended onto SimpleCov's singleton class to turn start into a no-op
-    # during mutant child runs. Using prepend avoids "method redefined" warnings.
-    module SimpleCovStartSuppressor
-      def start(*_args) = nil
-    end
-
-    # Minitest integration adapter.
-    #
-    # Coverage formatter injection remains implemented in the RSpec child
-    # runner. Minitest shares selection and execution semantics, but per-test
-    # coverage collection is not yet wired into this path.
-    class Minitest < Rspec
-      def per_test_coverage_supported?
-        true
-      end
-
-      def run_mutant(mutant:, test_files:, timeout:)
-        setup_load_path
-        super
-      end
-
-      def run_in_child(mutant:, test_files:, log_paths:)
-        ENV["RAILS_ENV"] = "test" unless ENV["RAILS_ENV"] == "test"
-        preload_environment
-        super
-      end
-
-      def run_suite(test_files, timeout: DEFAULT_SUITE_TIMEOUT)
-        log_paths = scenario_log_paths("baseline")
-        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
 
-      def suite_command(test_files)
-        ["bundle", "exec", "ruby", "-I", "test",
-         "-r", "henitai/minitest_simplecov",
-         "-r", "henitai/minitest_coverage_hook",
-         "-e", "ARGV.each { |f| require File.expand_path(f) }",
-         *test_files]
-      end
-
       def run_tests(test_files)
-        suppress_simplecov!
-        test_files.each { |file| require File.expand_path(file) }
-        # @type var empty_args: Array[String]
-        empty_args = []
-        status = ::Minitest.run(empty_args)
+        require "rspec/core"
+        ::RSpec.__send__(:configuration).fail_if_no_examples = true
+        debug_child_rspec_trace(test_files:, rspec_options: [], rspec_argv: test_files)
+        debug_child_example_count("before_run") # steep:ignore Ruby::NoMethod
+        debug_child_puts("[henitai-debug-child] runner_run_start")
+        status = run_rspec_runner(test_files)
+        debug_child_puts("[henitai-debug-child] runner_run_return status=#{status.inspect}")
+        debug_child_example_count("after_run") # steep:ignore Ruby::NoMethod
+        debug_child_rspec_exit(status)
         return status if status.is_a?(Integer)
 
         status == true ? 0 : 1
       end
-
-      def preload_environment
-        env_file = File.expand_path("config/environment.rb")
-        require env_file if File.exist?(env_file)
-      end
-
-      def setup_load_path
-        test_dir = File.expand_path("test")
-        $LOAD_PATH.unshift(test_dir) unless $LOAD_PATH.include?(test_dir)
-      end
-
-      def suppress_simplecov!
-        require "simplecov"
-        sc = Object.const_get(:SimpleCov) # steep:ignore Ruby::UnknownConstant
-        return if sc.singleton_class.ancestors.include?(SimpleCovStartSuppressor)
-
-        sc.singleton_class.prepend(SimpleCovStartSuppressor)
-      rescue LoadError, NameError
-        nil
-      end
-
-      def subprocess_env
-        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/") }
-      end
     end
   end
 end
+
+require_relative "integration/minitest"