mutineer 0.10.0 → 0.11.1

data/lib/mutineer/runner.rb

@@ -90,7 +90,7 @@ module Mutineer
           load_paths: config.load_paths, framework: config.framework,
           boot_path: File.expand_path(config.boot, config.project_root),
           verbose: config.verbose
-        ).build_via_fork(rails: config.rails)
+        ).build_via_fork(after_fork: (config.rails ? -> { reconnect_active_record } : nil))
       else
         coverage_map = CoverageMap.new(
           source_paths: config.sources, test_paths: config.tests,
@@ -112,13 +112,15 @@ module Mutineer
       sweep_orphans(dirs)
 
       strategy = config.strategy
+      # Fail-fast must be serial: a parallel stop_when fires on the first survivor
+      # by wall-clock, not input order, so the survivor set would diverge from
+      # --jobs 1 (daemon already forces serial for the same reason).
+      jobs_n = config.fail_fast ? 1 : config.jobs
       results =
         begin
           framework = config.framework
-          # #21: --fail-fast stops scheduling new mutants after the first survivor;
-          # in-flight workers drain, unscheduled jobs stay nil (dropped below).
           stop_when = config.fail_fast ? ->(r) { r.survived? } : nil
-          bare = WorkerPool.new(config.jobs).run(jobs, stop_when: stop_when) do |subject, mutation|
+          bare = WorkerPool.new(jobs_n).run(jobs, stop_when: stop_when) do |subject, mutation|
             run(mutation, source_file: subject.file, coverage_map: coverage_map,
                 subject: subject, strategy: strategy, rails: config.rails, framework: framework)
           end
@@ -229,69 +231,247 @@ module Mutineer
       end
     end
 
-    # #26/#27 Phase 2a — daemon backend orchestration (serial). Boots the app ONCE in
-    # a persistent subprocess and forks per mutant, restoring the one-boot speed the
-    # Phase 1 subprocess path gives up. Tool-side we build the ready-to-`load` payload
-    # (KTD-2/KTD-3: whole-file reload by default — the spike-proven path) and ship it;
-    # the daemon needs no Prism/mutineer. Serial in 2a (worker-DB isolation +
-    # parallelism is Phase 2b). No coverage narrowing yet (Phase 2c), so every mutant
-    # runs the full `--test` set.
+    # Daemon backend: boot the app once in a persistent subprocess and fork per
+    # mutant. Tool-side we build the ready-to-`load` payload (whole-file reload by
+    # default) and ship it; the daemon needs no Prism/mutineer. Coverage is built
+    # once via a short-lived daemon so each mutant runs only its covering tests.
+    # When jobs > 1, each worker uses its own database (SQLite). Fail-fast forces
+    # serial so the survivor set matches jobs 1.
     #
     # @return [Array(Mutineer::AggregateResult, Hash<String,String>)] aggregate and source map.
     def self.execute_daemon(config, operator_classes)
       jobs, ignored_results, source_map = collect_jobs(config, operator_classes)
       jobs = filter_since(jobs, source_map, config) if config.since
-
       abs_tests = config.tests.map { |t| File.expand_path(t, config.project_root) }
-      client = DaemonClient.new(boot: daemon_boot_config(config, abs_tests),
+
+      # Build the coverage map once (app-side). nil when the build fails — runners
+      # fall back to the full --test set (and emit a stderr warning) rather than
+      # mis-scoring everything as no_coverage.
+      coverage_map = daemon_coverage_map(config, abs_tests)
+
+      # #26/U6: worker count = resolved --jobs, capped at the job count (no idle
+      # daemons). >1 → N concurrent daemon handles, each on its OWN worker DB (V6:
+      # N-handles, the spike-proven shape). 1 → the serial single-daemon path.
+      # --fail-fast forces serial: parallel's stop flag fires on the first survivor
+      # by WALL-CLOCK, not input index, so the verdict set would diverge from serial
+      # (a different, non-deterministic survivor set/score) — the "identical to
+      # --jobs 1" guarantee below only holds when fail-fast can't race.
+      worker_count = [config.jobs || 1, 1].max
+      worker_count = 1 if config.fail_fast
+      worker_count = [worker_count, jobs.size].min if jobs.size.positive?
+
+      results =
+        if worker_count > 1
+          run_daemon_parallel(jobs, worker_count, config, abs_tests, coverage_map, source_map)
+        else
+          run_daemon_serial(jobs, config, abs_tests, coverage_map, source_map)
+        end
+
+      [AggregateResult.new(results + ignored_results), source_map]
+    end
+
+    # Build the coverage map via a short-lived daemon (boots the app once, captures
+    # per-test coverage app-side, ships the map back). Returns a query-only
+    # CoverageMap, or nil when the build fails / returns empty — callers then run the
+    # full --test set. Coverage-build IPC has no wall-clock (same limitation as
+    # in-process build_via_fork). A normal nonempty map scores like in-process;
+    # nil falls back to the full suite (more testing, not comparable).
+    #
+    # @param config [Mutineer::Config] the run config.
+    # @param abs_tests [Array<String>] absolute --test paths.
+    # @return [Mutineer::CoverageMap, nil]
+    def self.daemon_coverage_map(config, abs_tests)
+      client = DaemonClient.new(boot: daemon_boot_config(config, abs_tests, coverage: true),
                                 app_root: config.project_root).start
+      data = begin
+        client.coverage
+      ensure
+        client.quit
+      end
+      unless data && !(data["map"] || {}).empty?
+        reason = data.is_a?(Hash) && data["error"] ? data["error"] : "empty map"
+        warn_daemon_coverage_fallback(reason)
+        return nil
+      end
 
+      CoverageMap.from_data(map: data["map"], failed_test_files: data["failed_test_files"] || [],
+                            project_root: config.project_root)
+    rescue DaemonBootError => e
+      warn_daemon_coverage_fallback("#{e.class}: #{e.message}")
+      nil
+    end
+
+    # Stderr note when daemon coverage is unavailable (full --test set per mutant).
+    #
+    # @api private
+    # @param reason [String] short cause (boot error message, empty map, …).
+    # @return [void]
+    def self.warn_daemon_coverage_fallback(reason = "unknown")
+      warn "[mutineer] daemon coverage map unavailable (#{reason}); running every " \
+           "mutant against the full --test set (score not comparable to an in-process run)."
+    end
+    private_class_method :warn_daemon_coverage_fallback
+
+    # Serial daemon path: one daemon (worker 0), one mutant at a time. Honors
+    # --fail-fast (#21: stop at the first survivor).
+    #
+    # @return [Array<Mutineer::Result>] results in input order.
+    def self.run_daemon_serial(jobs, config, abs_tests, coverage_map, source_map)
+      client = DaemonClient.new(boot: daemon_boot_config(config, abs_tests),
+                                app_root: config.project_root).start
       results = []
       begin
-        jobs.each_with_index do |(subject, mutation, id), i|
-          source  = source_map[subject.file]
-          mutated = mutation.apply(source)
-          # KTD-8 (carried): skip an invalid mutant tool-side — never ship a payload
-          # that would fail to load and read as a false `killed`.
-          r =
-            if Parser.parse_string(mutated).errors.any?
-              Result.skipped
-            else
-              verdict = client.request(
-                id: i, timeout: config.daemon_timeout || DAEMON_TIMEOUT,
-                payload: { "code" => mutated, "source_file" => File.expand_path(subject.file, config.project_root) },
-                tests: abs_tests
-              )
-              daemon_result(verdict)
-            end
-          results << r.with(subject: subject, mutation: mutation, id: id)
-          break if config.fail_fast && r.survived? # #21: stop at the first survivor
+        jobs.each_with_index do |job, i|
+          r = daemon_job_result(job, i, client, 0, config, coverage_map, abs_tests, source_map)
+          results << r
+          break if config.fail_fast && r.survived?
         end
       ensure
         client.quit
       end
+      results
+    end
 
-      [AggregateResult.new(results + ignored_results), source_map]
+    # Parallel daemon path: N daemon handles, each pinned to its own worker slot
+    # (own DB). A shared queue of job indices feeds N tool-side threads; results
+    # are placed by input index so the verdict set matches serial. Callers must
+    # not pass fail_fast here (execute_daemon forces serial for fail-fast).
+    #
+    # @return [Array<Mutineer::Result>] completed results in input order.
+    def self.run_daemon_parallel(jobs, worker_count, config, abs_tests, coverage_map, source_map)
+      results = Array.new(jobs.size)
+      queue   = Queue.new
+      jobs.each_index { |i| queue << i }
+
+      clients = Array.new(worker_count) do
+        DaemonClient.new(boot: daemon_boot_config(config, abs_tests),
+                         app_root: config.project_root).start
+      end
+
+      clients.each_with_index.map do |client, worker|
+        Thread.new do
+          loop do
+            i = begin
+              queue.pop(true)
+            rescue ThreadError
+              break
+            end
+            results[i] = daemon_job_result(jobs[i], i, client, worker, config, coverage_map, abs_tests, source_map)
+          end
+        ensure
+          client.quit
+        end
+      end.each(&:join)
+
+      results.compact
+    end
+
+    # Build the payload for one job, run it on the given daemon/worker, and attach
+    # the subject/mutation/id — the shared body of both daemon paths.
+    #
+    # @param job [Array(Mutineer::Subject, Mutineer::Mutation, String)] the work item.
+    # @param req_id [Integer] request id (echoed back for IPC ordering safety).
+    # @param client [Mutineer::DaemonClient] the daemon handle to run on.
+    # @param worker [Integer] the worker slot (→ worker DB) this daemon routes to.
+    # @return [Mutineer::Result] the decorated result.
+    def self.daemon_job_result(job, req_id, client, worker, config, coverage_map, abs_tests, source_map)
+      subject, mutation, id = job
+      source  = source_map[subject.file]
+      mutated = mutation.apply(source)
+      # KTD-8 (carried): skip an invalid mutant tool-side — never ship a payload that
+      # would fail to load and read as a false `killed`.
+      # #26/U7: narrow to covering tests (shared with the in-process path via
+      # coverage_selection, so scores match). :verdict = no_coverage/uncapturable, no
+      # fork. No map (build failed) → run the full --test set (fallback, not narrowed).
+      sel = coverage_map && coverage_selection(subject.file, mutation, subject, source, coverage_map)
+      r =
+        if Parser.parse_string(mutated).errors.any?
+          Result.skipped
+        elsif sel && sel[0] == :verdict
+          sel[1]
+        else
+          verdict = client.request(
+            id: req_id, worker: worker, timeout: config.daemon_timeout || DAEMON_TIMEOUT,
+            payload: { "code" => mutated, "source_file" => File.expand_path(subject.file, config.project_root) },
+            tests: sel ? sel[1] : abs_tests
+          )
+          daemon_result(verdict)
+        end
+      r.with(subject: subject, mutation: mutation, id: id)
+    end
+
+    # Coverage-based test selection, shared by the in-process ({run}) and daemon
+    # paths so both narrow identically (score parity, U7/V5). Returns
+    # `[:run, abs_test_paths]` when some test covers the mutant's line, or
+    # `[:verdict, Result]` (no_coverage / uncapturable) when none do.
+    #
+    # #9/#25: an empty selection is `:uncapturable` (not `:no_coverage`) when the
+    # mutant's enclosing method body got coverage from no *successful* capture but a
+    # sibling test failed to capture — the coverage was lost, not absent. Both are
+    # excluded from the score denominator, so this distinction is reporting-only and
+    # never changes the daemon-vs-in-process score.
+    #
+    # @param source_file [String] the mutated source file path.
+    # @param mutation [Mutineer::Mutation] the mutation (for its line offset).
+    # @param subject [Mutineer::Subject, nil] the subject (for its method body range).
+    # @param source [String] the original source text.
+    # @param coverage_map [Mutineer::CoverageMap] the built/loaded coverage map.
+    # @return [Array(Symbol, Object)] `[:run, Array<String>]` or `[:verdict, Result]`.
+    def self.coverage_selection(source_file, mutation, subject, source, coverage_map)
+      line   = source.byteslice(0, mutation.start_offset).count("\n") + 1
+      chosen = coverage_map.tests_for(source_file, line)
+      if chosen.empty?
+        # Method BODY range, not the whole def: the def/end lines are "covered" at
+        # class-load even when the body never runs (body_loc is the statements' span).
+        loc   = subject&.body_loc
+        range = loc ? (loc.start_line..loc.end_line) : (line..line)
+        return [:verdict, coverage_map.method_uncapturable?(source_file, range) ? Result.uncapturable : Result.no_coverage]
+      end
+
+      [:run, chosen.map { |t| File.expand_path(t, coverage_map.project_root) }]
     end
 
-    # Default per-mutant timeout on the daemon path. Generous because 2a runs the full
-    # `--test` set per mutant (no coverage narrowing until Phase 2c).
+    # Default per-mutant timeout on the daemon path (seconds). Coverage narrowing
+    # usually keeps each job short; this still covers a slow suite or full-suite
+    # fallback when the coverage map is unavailable.
     DAEMON_TIMEOUT = 60
 
     # The boot config the daemon needs to boot the app once: where to boot, the test
     # load roots (so `require "test_helper"` resolves in every fork), framework, and
     # whether this is Rails.
-    def self.daemon_boot_config(config, abs_tests)
+    def self.daemon_boot_config(config, abs_tests, coverage: false)
       {
         project_root: config.project_root,
         boot: File.expand_path(config.boot || "config/environment", config.project_root),
         load_paths: test_load_roots(abs_tests),
         source_dirs: source_dirs(config), # so the daemon can sweep orphan mutant temps
         framework: config.framework,
-        rails: config.rails
+        rails: config.rails,
+        # #26/U5: schema for per-worker DB isolation. Sent when present; the daemon
+        # skips worker-DB schema loading if the path is absent (e.g. structure.sql apps).
+        schema: daemon_schema_path(config),
+        # #26/U7: coverage narrowing. Only the short-lived map-building daemon starts
+        # Coverage (before boot); worker daemons boot with it OFF (no wasted
+        # instrumentation/memory across every mutant fork). `sources`/`tests` are the
+        # map-build inputs.
+        coverage: coverage,
+        sources: config.sources.map { |s| File.expand_path(s, config.project_root) },
+        tests: abs_tests
       }
     end
 
+    # Absolute path to the app's `db/schema.rb` if it exists, else nil. Used by the
+    # daemon to schema-load each fork's isolated worker database (#26/U5). Only
+    # `schema.rb` is supported this pass; `structure.sql` apps get nil and fall back to
+    # whatever the worker DB already holds (Postgres provisioning is U10).
+    #
+    # @param config [Mutineer::Config] the run config.
+    # @return [String, nil] absolute schema path or nil.
+    def self.daemon_schema_path(config)
+      path = File.expand_path("db/schema.rb", config.project_root)
+      File.exist?(path) ? path : nil
+    end
+
     # Map a daemon verdict string to a Result. The daemon reports the four run-time
     # states it can decide (KTD-5); pre-fork states (skipped/no_coverage/…) are
     # resolved tool-side before a request is ever sent.
@@ -426,24 +606,12 @@ module Mutineer
 
       # 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)
-      # #9/#25: distinguish a genuine coverage gap from a line whose would-be test
-      # errored during capture (coverage lost) — the latter is :uncapturable.
-      # #25: taint per-METHOD (the mutant's enclosing def range), not whole-file,
-      # so a covered method's uncovered line stays :no_coverage while a method
-      # reachable only by a failed capture is :uncapturable.
-      if chosen.empty?
-        # Use the method BODY range, not the whole def: the `def`/`end` lines are
-        # "covered" at class-load even when the body never runs, which would mask
-        # an uncovered method. body_loc is the body statements' span.
-        loc = subject&.body_loc
-        range = loc ? (loc.start_line..loc.end_line) : (line..line)
-        return coverage_map.method_uncapturable?(source_file, range) ? Result.uncapturable : Result.no_coverage
-      end
+      # covering test files run in the child. Shared with the daemon path so both
+      # narrow identically (score parity, U7/V5).
+      kind, payload = coverage_selection(source_file, mutation, subject, source, coverage_map)
+      return payload if kind == :verdict
 
-      abs_tests = chosen.map { |t| File.expand_path(t, coverage_map.project_root) }
+      abs_tests = payload
 
       Isolation.run(timeout: timeout) do
         # Forking inherits the parent's live DB connection; sharing one socket

data/lib/mutineer/version.rb

@@ -2,5 +2,5 @@
 
 module Mutineer
   # Current Mutineer release version.
-  VERSION = "0.10.0"
+  VERSION = "0.11.1"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mutineer
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.11.1
 platform: ruby
 authors:
 - David Teren
@@ -95,6 +95,7 @@ files:
 - lib/mutineer/pairing.rb
 - lib/mutineer/parser.rb
 - lib/mutineer/project.rb
+- lib/mutineer/rails_worker_db.rb
 - lib/mutineer/reporter.rb
 - lib/mutineer/result.rb
 - lib/mutineer/runner.rb