henitai 0.2.0 → 0.3.0

data/lib/henitai/integration/rspec_child_runner.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Henitai
+  module Integration
+    # Drives an in-process RSpec run inside the mutant child. Kept separate
+    # from the framework-agnostic debug helpers so the RSpec-specific runner
+    # wiring stays in one place.
+    module RspecChildRunner
+      private
+
+      def run_rspec_runner(test_files)
+        debug_child_puts("[henitai-debug-child] build_rspec_runner_start")
+        runner = build_rspec_runner
+        debug_child_puts("[henitai-debug-child] build_rspec_runner_return")
+        debug_child_puts("[henitai-debug-child] configure_rspec_runner_start")
+        configure_rspec_runner(runner)
+        debug_child_puts("[henitai-debug-child] configure_rspec_runner_return")
+        load_rspec_spec_files(test_files)
+        run_rspec_specs(runner)
+      rescue SystemExit => e
+        debug_child_puts("[henitai-debug-child] runner_run_system_exit status=#{e.status.inspect}")
+        raise
+      ensure
+        debug_child_puts("[henitai-debug-child] runner_run_ensure")
+      end
+
+      def build_rspec_runner
+        # @type var empty_args: Array[String]
+        empty_args = []
+        configuration_options = ::RSpec::Core.const_get(:ConfigurationOptions).new(empty_args)
+        ::RSpec::Core::Runner.__send__(:new, configuration_options)
+      end
+
+      def configure_rspec_runner(runner)
+        debug_child_puts("[henitai-debug-child] trap_interrupt_start")
+        ::RSpec::Core::Runner.__send__(:trap_interrupt)
+        debug_child_puts("[henitai-debug-child] trap_interrupt_return")
+        debug_child_puts("[henitai-debug-child] runner_configure_start")
+        runner.send(:configure, $stderr, $stdout)
+        debug_child_puts("[henitai-debug-child] runner_configure_return")
+      end
+
+      def load_rspec_spec_files(test_files)
+        debug_child_puts("[henitai-debug-child] load_spec_files_start")
+        ::RSpec.configuration.files_to_run = test_files.map do |file|
+          File.expand_path(file)
+        end
+        ::RSpec.configuration.load_spec_files
+        debug_child_example_count("after_load")
+        debug_child_puts("[henitai-debug-child] load_spec_files_return")
+      end
+
+      def run_rspec_specs(runner)
+        debug_child_puts("[henitai-debug-child] run_specs_start")
+        result = runner.send(:run_specs, ::RSpec.world.ordered_example_groups)
+        debug_child_puts("[henitai-debug-child] run_specs_return result=#{result.inspect}")
+        result
+      end
+    end
+  end
+end

data/lib/henitai/integration/rspec_test_selection.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module Henitai
+  module Integration
+    # Spec-file discovery and subject-to-spec matching for the RSpec
+    # integration. Selection uses longest-prefix matching against the subject
+    # expression and namespace, with a transitive require-based fallback.
+    module RspecTestSelection
+      REQUIRE_DIRECTIVE_PATTERN = /
+        \A\s*
+        (require|require_relative)
+        \s*
+        (?:\(\s*)?
+        ["']([^"']+)["']
+        \s*\)?
+      /x
+
+      def select_tests(subject)
+        matches = spec_files.select do |path|
+          content = File.read(path)
+          # rubocop:disable Style/ArrayIntersect -- content is a String (substring
+          # search), not a collection; `intersect?` would raise a TypeError.
+          selection_patterns(subject).any? { |pattern| content.include?(pattern) }
+          # rubocop:enable Style/ArrayIntersect
+        rescue StandardError
+          false
+        end
+
+        return matches unless matches.empty?
+
+        fallback_spec_files(subject)
+      end
+
+      private
+
+      def spec_files
+        @spec_files ||= begin
+          paths = Dir.glob("spec/**/*_spec.rb")
+          paths - excluded_spec_files
+        end
+      end
+
+      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
+        @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
+      end
+    end
+  end
+end

data/lib/henitai/integration/scenario_log_support.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+require "fileutils"
+
+module Henitai
+  module Integration
+    # Shared helpers for capturing stdout/stderr from child test processes and
+    # for reading and combining the captured log files afterwards.
+    class ScenarioLogSupport
+      # Env var carrying the per-stream capture cap (bytes) into forked
+      # children. Set by the execution engine from Configuration#max_log_bytes.
+      MAX_LOG_BYTES_ENV = "HENITAI_MAX_LOG_BYTES"
+      DEFAULT_MAX_LOG_BYTES = 5_000_000
+      DRAIN_CHUNK_BYTES = 65_536
+
+      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
+
+      # Captures via a pipe drained by a background thread that writes to the
+      # log file only up to +max_log_bytes+ and then discards the overflow.
+      # A runaway mutant (e.g. one that recurses henitai into itself and spews
+      # backtraces) can otherwise fill hundreds of MB per child; draining past
+      # the cap keeps the writer from blocking on a full pipe.
+      def open_child_output(log_paths)
+        FileUtils.mkdir_p(File.dirname(log_paths[:log_path]))
+        cap = max_log_bytes
+        output_files = {
+          original_stdout: stdout_stream.dup,
+          original_stderr: stderr_stream.dup,
+          stdout: open_capped_stream(log_paths[:stdout_path], cap),
+          stderr: open_capped_stream(log_paths[:stderr_path], cap)
+        }
+        redirect_child_output(output_files)
+        output_files
+      end
+
+      def close_child_output(output_files)
+        return unless output_files
+
+        restore_child_output(output_files)
+        finish_capped_stream(output_files[:stdout])
+        finish_capped_stream(output_files[:stderr])
+        output_files[:original_stdout]&.close
+        output_files[:original_stderr]&.close
+      end
+
+      # One capture channel: a pipe whose read end is drained (capped) into the
+      # log file by a dedicated thread. Returns the pieces close needs.
+      def open_capped_stream(path, cap)
+        file = File.new(path, "w")
+        file.sync = true
+        reader, writer = IO.pipe
+        thread = Thread.new { drain_capped(reader, file, cap) }
+        { file:, reader:, writer:, thread: }
+      end
+
+      def drain_capped(reader, file, cap)
+        written = 0
+        truncated = false
+        loop do
+          chunk = reader.readpartial(DRAIN_CHUNK_BYTES)
+          next unless written < cap
+
+          slice = chunk.byteslice(0, cap - written)
+          file.write(slice)
+          written += slice.bytesize
+          next unless written >= cap && !truncated
+
+          file.write("\n[henitai] output truncated at #{cap} bytes\n")
+          truncated = true
+        end
+      rescue IOError
+        # EOFError (a subclass) on writer close, or a closed pipe: draining done.
+        nil
+      end
+
+      def finish_capped_stream(stream)
+        return unless stream
+
+        stream[:writer].close
+        stream[:thread].join
+        stream[:reader].close
+        stream[:file].close
+      end
+
+      def redirect_child_output(output_files)
+        reopen_child_output_stream(stdout_stream, output_files[:stdout][:writer])
+        reopen_child_output_stream(stderr_stream, output_files[:stderr][:writer])
+        $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 max_log_bytes
+        raw = ENV.fetch(MAX_LOG_BYTES_ENV, nil)
+        value = raw.to_i
+        value.positive? ? value : DEFAULT_MAX_LOG_BYTES
+      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
+
+      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
+  end
+end