mutineer 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4020e2cd0e53ac4f406998d2c251d26abee9f75c4e6ceef365f2ffe565be50ab
-  data.tar.gz: f42dbc71077fc802b56f878e27885568f3d128f244875fb678dede5f6940f385
+  metadata.gz: 51400ef0019b1a18f5c4b548e7789d072cbd744bd7918aa402de83052b37d5b6
+  data.tar.gz: 31d84ebaf51dbed8a5fc9273aece37f2ea288af9e41efd8006c939439c318125
 SHA512:
-  metadata.gz: dc24bb60419b7d701a85a09c70495c9d9d7ce2cd2d5b5a10621cb03a940276c3526dc650ee4deb7f93529e09b67b872777c2483419979d5740a83aa9ac9bfd26
-  data.tar.gz: ff59317a64ab0e3478c7dde381ac9752b56c83920d1a63bcf6528ac826f286d787b2d560c1946e897790bd47325ac2209d22b537e3baa146b90f2bedcd2f0c72
+  metadata.gz: 3907408aad53671313f88203fefc9da64f6ee76bffc57b7754ed13b31f19f7a0311c61f6d7a074a21eea78ab6bd74d3143d51e3b25fa9a03eba49901b71c3d5f
+  data.tar.gz: e67bfedd8a82c97496e9ab2189c390826cc6e55678c6c88ab4f40df0b784f92237986e9651668c512839d9803d0f921308228722e2552f6886ead65597d7acfb

data/CHANGELOG.md

@@ -4,6 +4,14 @@ All notable changes to this project are documented here. The format is based on
 [Keep a Changelog](https://keepachangelog.com/), and this project adheres to
 [Semantic Versioning](https://semver.org/).
 
+## [0.3.0] - 2026-06-28
+
+### Added
+- **Coverage-guided test selection in boot mode** (#1) — `--rails`/`--boot` now
+  captures coverage by forking the booted app and runs only the test files that
+  cover each mutant's line (uncovered lines report `no_coverage`), instead of
+  running every `--test` file for every mutant. Cached like standalone mode.
+
 ## [0.2.0] - 2026-06-28
 
 ### Added
@@ -38,5 +46,6 @@ All notable changes to this project are documented here. The format is based on
 - `.mutineer.yml` configuration (CLI > config > default precedence).
 - Byte-correct source handling for multibyte (UTF-8) sources.
 
+[0.3.0]: https://github.com/davidteren/mutineer/releases/tag/v0.3.0
 [0.2.0]: https://github.com/davidteren/mutineer/releases/tag/v0.2.0
 [0.1.0]: https://github.com/davidteren/mutineer/releases/tag/v0.1.0

data/README.md

@@ -82,9 +82,9 @@ RAILS_ENV=test bundle exec mutineer run \
 then forks and inherits it), defaults `--strategy` to `redefine` (surgical — it
 avoids reloading files into the app tree), and reconnects ActiveRecord in each
 fork so the database connection is fork-safe. Use `--boot FILE` to boot a
-different entry point. Boot mode requires at least one `--test` file and runs
-those tests for every mutant (coverage-guided selection is not yet available in
-boot mode).
+different entry point. Boot mode requires at least one `--test` file and is
+coverage-guided — each mutant runs only the test files that exercise its line
+(coverage is captured by forking the booted app, then cached).
 
 Add Mutineer to your Gemfile's test group:
 

data/lib/mutineer/coverage_map.rb

@@ -5,6 +5,8 @@ require "json"
 require "digest"
 require "fileutils"
 require "rbconfig"
+require "coverage"
+require_relative "minitest_integration"
 
 module Mutineer
   # Maps `(source_file, line) -> [test_files]` so each mutant runs only against
@@ -21,24 +23,50 @@ module Mutineer
 
     def initialize(source_paths:, test_paths:, cache_dir: ".mutineer",
                    load_paths: ["lib"], project_root: Dir.pwd,
-                   capture_timeout: DEFAULT_CAPTURE_TIMEOUT)
+                   capture_timeout: DEFAULT_CAPTURE_TIMEOUT, boot_path: nil)
       @source_paths = Array(source_paths)
       @test_paths   = Array(test_paths)
       @cache_dir    = cache_dir
       @load_paths   = Array(load_paths)
       @project_root = project_root
       @capture_timeout = capture_timeout
+      @boot_path    = boot_path
       @map          = {}
       @failed_test_files = []
       @phase_a_ran  = false
     end
 
-    # Phase A entry point: load the cached map when the content digest matches,
-    # otherwise rebuild from subprocesses and overwrite the cache.
+    # Phase A entry point (standalone): load the cached map when the content
+    # digest matches, otherwise rebuild from subprocesses and overwrite the cache.
     def build_or_load
       warn_external_sources
-      @digest = compute_digest
+      cached_or { run_phase_a }
+    end
+
+    # Boot-mode Phase A: Coverage is already running in the parent (started before
+    # the app booted, so booted source lines are instrumented). A clean `ruby`
+    # subprocess has no booted env, so per-test coverage is captured by FORKING
+    # the booted parent instead. Inverts into the same map #tests_for reads, and
+    # reuses the digest cache (the digest mixes in the boot file so a boot cache
+    # never collides with a standalone one).
+    def build_via_fork(rails: false)
+      warn_external_sources
+      cached_or { run_phase_a_via_fork(rails: rails) }
+    end
 
+    # Phase B lookup: the test files that cover `file:line`, or [] when none do.
+    # ponytail: per-file granularity; upgrade to per-method when throughput
+    # warrants (requires Minitest method isolation + finer Coverage tracking).
+    def tests_for(file, line)
+      @map["#{relativize(file)}:#{line}"] || []
+    end
+
+    private
+
+    # Shared cache dance for both build paths: hit the digest-keyed cache, else
+    # yield to populate @map and persist it.
+    def cached_or
+      @digest = compute_digest
       cached = read_cache
       if cached && cached["digest"] == @digest
         @map = cached["map"] || {}
@@ -47,20 +75,11 @@ module Mutineer
         return self
       end
 
-      run_phase_a
+      yield
       save
       self
     end
 
-    # Phase B lookup: the test files that cover `file:line`, or [] when none do.
-    # ponytail: per-file granularity; upgrade to per-method when throughput
-    # warrants (requires Minitest method isolation + finer Coverage tracking).
-    def tests_for(file, line)
-      @map["#{relativize(file)}:#{line}"] || []
-    end
-
-    private
-
     def run_phase_a
       @phase_a_ran = true
       @map = {}
@@ -74,6 +93,65 @@ module Mutineer
       end
     end
 
+    # Boot-mode Phase A. For each test file, fork the booted parent; the child
+    # resets its Coverage delta, runs that ONE test, and marshals back the raw
+    # per-source coverage counts. record() inverts them exactly as the subprocess
+    # path does. ponytail: serial fork (one test at a time) — boot apps fork
+    # cheaply via COW and per-test isolation matters more than throughput here.
+    def run_phase_a_via_fork(rails:)
+      @phase_a_ran = true
+      @map = {}
+      @failed_test_files = []
+      abs_sources = abs_source_paths
+
+      @test_paths.each do |test_path|
+        coverage = fork_capture(absolute(test_path), abs_sources, rails)
+        next fail_test(test_path, "fork capture produced no result") unless coverage
+
+        record(coverage, test_path)
+      end
+    end
+
+    # Fork the booted parent, run one test under the inherited Coverage, and
+    # return its per-source counts hash (or nil on failure). Reuses the same
+    # fork + Marshal-over-pipe + hard-exit! discipline as WorkerPool/Isolation.
+    def fork_capture(abs_test, abs_sources, rails)
+      rd, wr = IO.pipe
+      pid = fork do
+        rd.close
+        payload =
+          begin
+            Runner.send(:reconnect_active_record) if rails
+            Coverage.result(clear: true, stop: false) # discard pre-test delta
+            MinitestIntegration.run([abs_test])
+            # lines:true yields {file => {lines: [...]}}; reduce to the counts
+            # array record() expects, keeping only our source files.
+            Coverage.result(stop: false)
+                    .select { |f, _| abs_sources.include?(f) }
+                    .transform_values { |v| v.is_a?(Hash) ? v[:lines] : v }
+          rescue Exception # rubocop:disable Lint/RescueException
+            nil
+          end
+        begin
+          wr.write(Marshal.dump(payload))
+        rescue StandardError # rubocop:disable Lint/SuppressedException
+          # pipe gone; parent records "no result"
+        ensure
+          wr.close
+          exit!(0) # skip at_exit so the parent suite's autorun never re-fires here
+        end
+      end
+      wr.close
+      data = rd.read
+      rd.close
+      Process.waitpid(pid)
+      return nil if data.empty?
+
+      Marshal.load(data)
+    rescue StandardError
+      nil
+    end
+
     # Spawns a fresh `ruby` reading an inline script from stdin. A fork would
     # miss already-loaded app lines, so Coverage must start in a clean process
     # before any source is loaded (KTD1/KTD2). Returns the parsed Coverage.result
@@ -154,10 +232,17 @@ module Mutineer
       d = Digest::SHA256.new
       digest_group(d, "source", @source_paths)
       digest_group(d, "test", @test_paths)
+      digest_group(d, "boot", [boot_digest_path]) if @boot_path
       @load_paths.sort.each { |lp| d.update("loadpath\0#{lp}\0") }
       d.hexdigest
     end
 
+    # boot_path is a require-style path (e.g. "config/environment", no extension);
+    # resolve it to the real file for reading, appending ".rb" when needed.
+    def boot_digest_path
+      File.exist?(absolute(@boot_path)) ? @boot_path : "#{@boot_path}.rb"
+    end
+
     def digest_group(digest, role, paths)
       paths.sort.each do |p|
         content = File.read(absolute(p))

data/lib/mutineer/runner.rb

@@ -38,29 +38,39 @@ module Mutineer
       # parse that needs nothing loaded. Standalone mode requires the sources as
       # before so their classes exist for the children to inherit.
       if config.boot
+        # Coverage instruments only files loaded AFTER it starts. Start it BEFORE
+        # the boot require so the entire app loaded during boot is instrumented;
+        # forked children then measure each test's coverage delta against it.
+        require "coverage"
+        Coverage.start(lines: true) unless Coverage.running?
         require File.expand_path(config.boot, config.project_root)
       else
         config.sources.each { |f| require File.expand_path(f, config.project_root) }
       end
       config.require_paths.each { |f| require File.expand_path(f, config.project_root) }
 
-      # Boot mode skips coverage selection entirely: every mutant runs the given
-      # --test files (precomputed absolute here, used directly by Runner.run).
       if config.boot
-        coverage_map = nil
-        boot_tests = config.tests.map { |t| File.expand_path(t, config.project_root) }
         # Rails/Minitest test files do `require "test_helper"`, which needs the
         # test root on $LOAD_PATH (`bin/rails test` adds it). Prepend each test
         # file's helper root here in the parent so loading them in the fork
-        # children resolves. Inherited by every fork.
+        # children (both coverage capture and per-mutant) resolves.
+        boot_tests = config.tests.map { |t| File.expand_path(t, config.project_root) }
         test_load_roots(boot_tests).each { |d| $LOAD_PATH.unshift(d) unless $LOAD_PATH.include?(d) }
+
+        # Boot mode now uses coverage selection too: capture each test's coverage
+        # by forking the booted parent, then select covering tests per mutant.
+        coverage_map = CoverageMap.new(
+          source_paths: config.sources, test_paths: config.tests,
+          cache_dir: config.cache_dir, project_root: config.project_root,
+          load_paths: config.load_paths,
+          boot_path: File.expand_path(config.boot, config.project_root)
+        ).build_via_fork(rails: config.rails)
       else
         coverage_map = CoverageMap.new(
           source_paths: config.sources, test_paths: config.tests,
           cache_dir: config.cache_dir, project_root: config.project_root,
           load_paths: config.load_paths
         ).build_or_load
-        boot_tests = nil
       end
 
       # Collect every (subject, mutation) up front so the pool can fan them out.
@@ -88,8 +98,7 @@ module Mutineer
         begin
           bare = WorkerPool.new(config.jobs).run(jobs) do |subject, mutation|
             run(mutation, source_file: subject.file, coverage_map: coverage_map,
-                subject: subject, strategy: strategy,
-                test_files: boot_tests, rails: config.rails)
+                subject: subject, strategy: strategy, rails: config.rails)
           end
           # The bare Results carry only status (Subjects hold live AST nodes that
           # do not marshal); reattach subject+mutation in the parent, in order.
@@ -131,24 +140,21 @@ module Mutineer
     end
 
     def self.run(mutation, source_file:, coverage_map: nil, subject: nil, strategy: "reload",
-                 timeout: Isolation::DEFAULT_TIMEOUT, test_files: nil, rails: false)
+                 timeout: Isolation::DEFAULT_TIMEOUT, rails: false)
       source  = File.read(source_file)
       mutated = mutation.apply(source)
 
       # Validity rule: a mutant that doesn't re-parse is skipped before forking.
       return Result.skipped if Parser.parse_string(mutated).errors.any?
 
-      # Boot mode passes its tests directly (already absolute); standalone mode
-      # selects covering tests from the map and is :no_coverage when none cover it.
-      if test_files
-        abs_tests = test_files
-      else
-        line   = source.byteslice(0, mutation.start_offset).count("\n") + 1
-        chosen = coverage_map.tests_for(source_file, line)
-        return Result.no_coverage if chosen.empty?
+      # Coverage selection (both standalone and boot mode): a mutation on a line
+      # no test exercises is :no_coverage (no fork); otherwise exactly the
+      # covering test files run in the child.
+      line   = source.byteslice(0, mutation.start_offset).count("\n") + 1
+      chosen = coverage_map.tests_for(source_file, line)
+      return Result.no_coverage if chosen.empty?
 
-        abs_tests = chosen.map { |t| File.expand_path(t, coverage_map.project_root) }
-      end
+      abs_tests = chosen.map { |t| File.expand_path(t, coverage_map.project_root) }
 
       Isolation.run(timeout: timeout) do
         # Forking inherits the parent's live DB connection; sharing one socket

data/lib/mutineer/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Mutineer
-  VERSION = "0.2.0"
+  VERSION = "0.3.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mutineer
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
 platform: ruby
 authors:
 - David Teren