saboteur 0.2.0 → 0.4.0

data/lib/saboteur/engine/coverage_store.rb

@@ -11,7 +11,7 @@ module Saboteur
     # unchanged, otherwise built by running the whole suite once in a
     # supervised child and saved.
     class CoverageStore
-      CACHE_INPUTS = %w[integration require rspec_args rails].freeze
+      CACHE_INPUTS = %w[integration require rspec_args rails tests].freeze
       LOCKFILES = %w[Gemfile.lock gems.locked].freeze
       LOG = "coverage-build.log"
 
@@ -27,9 +27,9 @@ module Saboteur
       def fetch(files)
         path = File.join(@config.path("cache_dir"), "coverage-#{cache_key(files)}.json")
         cached = @config["cache"] ? Selection::CoverageMap.load(path) : nil
-        return cached if cached
+        return refuse_empty_map(cached, files) if cached
 
-        map = build(files)
+        map = refuse_empty_map(build(files), files)
         map.save(path)
         map
       end
@@ -52,8 +52,15 @@ module Saboteur
                        "Run through the saboteur executable and disable SimpleCov for the run."
         end
 
-        @diagnostics.inform("building coverage map (runs the whole suite once)")
-        result = @supervisor.run(timeout: @config["coverage_timeout"]) { |writer| record(writer, files) }
+        scope = @config["tests"].empty? ? "the whole suite" : "the selected specs"
+        @diagnostics.inform("building coverage map (runs #{scope} once)")
+        # The suite child forked next inherits this heap; pack it first, to
+        # reduce later copying of shared pages.
+        Execution::ForkReadiness.prepare_heap
+        heartbeat = @diagnostics.progress_heartbeat("building coverage map")
+        result = @supervisor.run(timeout: @config["coverage_timeout"], on_tick: heartbeat.method(:tick)) do |writer|
+          record(writer, files)
+        end
         raise Error, "coverage map build stopped: #{result.detail}" if result.stopped_by
         raise Error, "coverage map build failed: #{died(result.exit_status)}" if result.payload.empty?
 
@@ -63,6 +70,29 @@ module Saboteur
         Selection::CoverageMap.from_json(result.payload)
       end
 
+      # A whole-suite build that records no line in any included file fails
+      # the run (exit 3): usually the setup hid the app from Coverage
+      # (Bootsnap's compile cache is the default Rails case); it can also
+      # mean no test in the suite exercises any included file. Either way a
+      # run on this map would test nothing, and exit 0 would lie. With
+      # explicit tests (--test) an empty map is a legitimate outcome
+      # instead: the user narrowed the suite to specs that may not touch
+      # these sources, so the map passes with a warning. Applies to a cached
+      # map too, so a map cached before this check cannot keep a run green,
+      # and the guard runs before saving, so an empty map is never cached.
+      def refuse_empty_map(map, files)
+        return map if files.empty? || map.lines.any? { |_file, by_line| by_line.any? }
+
+        if @config["tests"].empty?
+          raise Error, "Coverage recorded no lines in #{files.size} included files during a whole-suite " \
+                       "build. Is Bootsnap's compile cache on? If not, no test may exercise these files. " \
+                       "Run `saboteur doctor`."
+        end
+        @diagnostics.warn("Coverage recorded no lines in #{files.size} included files; " \
+                          "the selected specs may not exercise them.")
+        map
+      end
+
       def died(status)
         how = if status&.signaled? then "was killed by signal #{Signal.signame(status.termsig)}"
               else "exited with status #{status&.exitstatus}"
@@ -86,7 +116,11 @@ module Saboteur
         recorder = Selection::Recorder.new(files)
         recorder.start
         Kernel.srand(@config["seed"])
-        @integration.run_all(recorder)
+        passed = @integration.run_all(recorder)
+        if passed == false
+          raise Error, "the unchanged suite failed while building coverage. Fix the suite, then run again " \
+                       "with seed #{@config['seed']}."
+        end
         build_seconds = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started
         writer.write(recorder.result(build_seconds: build_seconds).to_json)
         writer.close

data/lib/saboteur/engine/data_inputs.rb

@@ -0,0 +1,43 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+module Saboteur
+  class Engine
+    # Non-Ruby files a test run can read and that change its outcome: Rails
+    # fixtures, schema dumps and database/environment configuration, plus
+    # anything listed under `fingerprint_extra`. Ruby files are tracked
+    # elsewhere; these have no .rb extension, so the Ruby walk misses them.
+    # An absent pattern simply matches nothing, so plain gems are unaffected.
+    module DataInputs
+      GLOBS = %w[
+        spec/fixtures/**/*
+        spec/**/fixtures/**/*
+        test/fixtures/**/*
+        db/structure.sql
+        db/schema.rb
+        config/database.yml
+        config/database.yml.erb
+        config/*.yml
+        config/environments/*.yml
+        config/credentials/*.yml.enc
+      ].freeze
+
+      # True when the absolute path is one of the declared inputs, whether or
+      # not the file exists yet. A run must never write there.
+      def self.match?(root, path, extra: [])
+        return false unless path.start_with?("#{root}/")
+
+        relative = path.delete_prefix("#{root}/")
+        flags = File::FNM_PATHNAME | File::FNM_DOTMATCH | File::FNM_EXTGLOB
+        (GLOBS + extra).any? { |pattern| File.fnmatch?(pattern, relative, flags) }
+      end
+
+      # Sorted absolute paths of regular files (symlinks followed) under root.
+      def self.files(root, extra: [])
+        (GLOBS + extra).flat_map { |pattern| Dir.glob(pattern, File::FNM_DOTMATCH, base: root) }
+                       .map { |relative| File.join(root, relative) }
+                       .select { |path| File.file?(path) }.uniq.sort
+      end
+    end
+  end
+end

data/lib/saboteur/engine/diagnostics.rb

@@ -6,6 +6,26 @@ module Saboteur
     # What a run has to say besides results: warnings for the report, the
     # count of mutations dropped for not parsing, and progress marks.
     class Diagnostics
+      # See progress_heartbeat. Time-gated itself, so the supervisor can
+      # call tick on every poll.
+      class ProgressHeartbeat
+        def initialize(diagnostics, label, interval: 30)
+          @diagnostics = diagnostics
+          @label = label
+          @interval = interval
+          @started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          @last_print = @started
+        end
+
+        def tick
+          now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          return if now - @last_print < @interval
+
+          @last_print = now
+          @diagnostics.inform("#{@label}: #{(now - @started).round} s elapsed")
+        end
+      end
+
       MARKS = { killed: ".", survived: "S", timeout: "T", resource_limit: "L", error: "E" }.freeze
 
       attr_reader :warnings, :invalid_mutations
@@ -28,6 +48,14 @@ module Saboteur
         @err.puts("saboteur: #{message}")
       end
 
+      # A heartbeat for a long phase: the supervisor's wait loop calls tick
+      # in the parent after the fork, so no extra thread is ever alive at
+      # fork time. Prints "<label>: N s elapsed" about every interval
+      # seconds, so a long phase does not look stuck.
+      def progress_heartbeat(label, interval: 30)
+        ProgressHeartbeat.new(self, label, interval: interval)
+      end
+
       def progress(result)
         @err.print(MARKS.fetch(result.status, "?"))
         @err.flush

data/lib/saboteur/engine/diff_scope.rb

@@ -20,6 +20,14 @@ module Saboteur
         end
       end
 
+      # The changed lines a mutant touches, sorted. A statement that spans
+      # several lines is mutated as one piece and reported at its first line,
+      # which can sit above the line that changed; this names the changed line.
+      def changed_lines_for(subject, mutation)
+        changed = @changed_lines.fetch(subject.file, Set.new)
+        mutation.edits.flat_map { |edit| edited_lines(subject, edit).to_a }.uniq.select { changed.include?(_1) }.sort
+      end
+
       private
 
       def edited_lines(subject, edit)

data/lib/saboteur/engine/distribution.rb

@@ -42,7 +42,8 @@ module Saboteur
           "position" => list.index { |mutation, _| mutation.equal?(result.mutation) },
           "status" => result.status.to_s, "reason" => result.reason, "runtime" => result.runtime,
           "killed_by" => result.killed_by, "covered_by" => result.covered_by,
-          "kill_cause" => result.kill_cause, "reused" => result.reused?
+          "kill_cause" => result.kill_cause, "reused" => result.reused?,
+          "rejected_kill" => result.rejected_kill?
         }
       end
 
@@ -55,7 +56,8 @@ module Saboteur
           result = MutantResult.new(subject: subject, mutation: mutation, status: data["status"].to_sym,
                                     mutated_source: text, reason: data["reason"], runtime: data["runtime"],
                                     killed_by: data["killed_by"], covered_by: data["covered_by"],
-                                    kill_cause: data["kill_cause"], reused: data["reused"])
+                                    kill_cause: data["kill_cause"], reused: data["reused"],
+                                    rejected_kill: data.fetch("rejected_kill", false))
           @cache&.record(result) unless result.reused?
           result
         end

data/lib/saboteur/engine/run_fingerprint.rb

@@ -0,0 +1,344 @@
+# SPDX-License-Identifier: MIT
+# frozen_string_literal: true
+
+require "digest"
+require "json"
+require_relative "data_inputs"
+
+module Saboteur
+  class Engine
+    # Read-only identity for declared project inputs, not a Ruby dependency graph.
+    # Capture before boot; verify before reuse/save. Unknown inputs are unsafe.
+    class RunFingerprint
+      FORMAT_VERSION = 1
+      MANIFESTS = %w[Gemfile gems.rb Gemfile.lock gems.locked .rspec .rspec-local].freeze
+      LOCATION_SETTINGS = %w[cache_dir json_report html_report].freeze
+      ENTRY_KINDS = %w[ruby manifest boot hook source_plugin extra data].freeze
+      EXCLUDED_DIRECTORIES = %w[.git vendor node_modules].freeze
+      Entry = Data.define(:path, :kind, :state, :sha256, :required)
+      Change = Data.define(:path, :reason)
+      Snapshot = Data.define(:format_version, :digest, :inventory, :settings_digest, :runtime_digest, :complete,
+                             :issues) do
+        def to_h
+          super.merge(inventory: inventory.map(&:to_h))
+        end
+      end
+      Verification = Data.define(:unchanged, :complete, :current_digest, :changes, :issues)
+
+      def self.restore_snapshot(hash)
+        fields = canonical_mapping(hash).transform_keys(&:to_sym)
+        validate_snapshot_fields(fields)
+        inventory = fields.fetch(:inventory).map { |entry| restore_entry(entry) }.freeze
+        raise ArgumentError, "duplicate inventory paths" unless inventory.map(&:path).uniq.size == inventory.size
+
+        issues = restore_issues(fields.fetch(:issues))
+        validate_snapshot_identity(fields, inventory, issues)
+        Snapshot.new(**fields, inventory: inventory, issues: issues)
+      rescue KeyError, TypeError, NoMethodError => e
+        raise ArgumentError, "invalid fingerprint snapshot: #{e.class}"
+      end
+
+      def self.restore_issues(issues)
+        raise ArgumentError, "invalid issues" unless
+          issues.is_a?(Array) && issues.all?(String) && issues == issues.uniq.sort
+
+        issues.map { |issue| issue.dup.freeze }.freeze
+      end
+
+      def self.validate_snapshot_identity(fields, inventory, issues)
+        raise ArgumentError, "invalid complete snapshot" if
+          fields[:complete] && (issues.any? || inventory.any? do |entry|
+            entry.state == "unreadable" || (entry.required && entry.state == "missing")
+          end)
+        raise ArgumentError, "unsorted inventory" unless inventory.map(&:path) == inventory.map(&:path).sort
+
+        inputs = { format: FORMAT_VERSION, files: inventory.map(&:to_h),
+                   settings: fields[:settings_digest], runtime: fields[:runtime_digest] }
+        canonical = canonical_value(inputs)
+        raise ArgumentError, "fingerprint identity mismatch" unless
+          Digest::SHA256.hexdigest(JSON.generate(canonical)) == fields[:digest]
+      end
+
+      def self.validate_snapshot_fields(fields)
+        raise ArgumentError, "invalid snapshot fields" unless fields.keys.sort == Snapshot.members.sort
+        raise ArgumentError, "unsupported fingerprint format" unless fields[:format_version] == FORMAT_VERSION
+        raise ArgumentError, "invalid completeness" unless [true, false].include?(fields[:complete])
+
+        %i[digest settings_digest runtime_digest].each do |key|
+          raise ArgumentError, "invalid fingerprint digest" unless fields.fetch(key).match?(/\A[0-9a-f]{64}\z/)
+        end
+      end
+
+      def self.restore_entry(entry)
+        values = canonical_mapping(entry).transform_keys(&:to_sym)
+        raise ArgumentError, "invalid fingerprint entry" unless valid_entry?(values)
+
+        Entry.new(**values)
+      end
+
+      def self.valid_entry?(values)
+        values.keys.sort == %i[kind path required sha256 state] && valid_path?(values[:path]) &&
+          [true,
+           false].include?(values[:required]) && ENTRY_KINDS.include?(values[:kind]) &&
+          (!%w[ruby boot hook
+               source_plugin].include?(values[:kind]) || values[:required]) && valid_state?(values[:state],
+                                                                                            values[:sha256])
+      end
+
+      def self.valid_path?(path)
+        unless path.is_a?(String) && !path.empty? && !path.include?("\0") &&
+               !path.include?("\\") && !path.end_with?("/")
+          return false
+        end
+
+        candidate = path.delete_prefix("external:")
+        absolute = path.start_with?("external:")
+        return false unless candidate.start_with?("/") == absolute
+
+        segments = candidate.split("/")
+        segments.shift if absolute
+        segments.none? { |part| part.empty? || %w[. ..].include?(part) }
+      end
+
+      def self.valid_state?(state, digest)
+        return digest.is_a?(String) && digest.match?(/\A[0-9a-f]{64}\z/) if state == "present"
+
+        %w[missing unreadable].include?(state) && digest.nil?
+      end
+
+      def self.runtime_identity
+        { engine: RUBY_ENGINE, version: RUBY_VERSION, platform: RUBY_PLATFORM,
+          patchlevel: RUBY_PATCHLEVEL, saboteur: VERSION }
+      end
+
+      def initialize(config:, root: config.root, extra_files: [], runtime_identity: self.class.runtime_identity)
+        @config = config
+        @root = File.realpath(root)
+        raise ArgumentError, "root differs from config.root" unless @root == File.realpath(config.root)
+
+        @extra_files = extra_files.map do |file|
+          options = file.is_a?(Hash) ? file : { path: file, required: true }
+          [File.expand_path(options.fetch(:path), @root), options.fetch(:required, true)]
+        end.freeze
+        @runtime_identity = canonical(runtime_identity)
+      end
+
+      def snapshot
+        issues = output_overlap_issues
+        entries = inventory(issues).sort_by(&:path).freeze
+        issues = issues.uniq.sort
+        settings_digest = hash_value(@config.to_h.except(*LOCATION_SETTINGS))
+        runtime_digest = hash_value(@runtime_identity)
+        digest = hash_value(format: FORMAT_VERSION, files: entries.map(&:to_h),
+                            settings: settings_digest, runtime: runtime_digest)
+        Snapshot.new(format_version: FORMAT_VERSION, digest: digest, inventory: entries,
+                     settings_digest: settings_digest, runtime_digest: runtime_digest,
+                     complete: issues.empty?, issues: issues.freeze)
+      end
+
+      def verify(previous)
+        current = snapshot
+        changes = changes_between(previous, current)
+        complete = previous.complete && current.complete && previous.format_version == FORMAT_VERSION
+        Verification.new(unchanged: complete && previous.digest == current.digest,
+                         complete: complete, current_digest: current.digest,
+                         changes: changes.freeze, issues: current.issues)
+      end
+
+      def self.canonical_value(value)
+        case value
+        when Hash then canonical_mapping(value)
+        when Array then value.map { |entry| canonical_value(entry) }.freeze
+        when String then value.dup.freeze
+        when NilClass, TrueClass, FalseClass, Integer then value
+        when Float
+          raise ArgumentError, "non-finite identity number" unless value.finite?
+
+          value
+        else raise ArgumentError, "unsupported identity value"
+        end
+      end
+
+      def self.canonical_mapping(value)
+        raise ArgumentError, "invalid identity key" unless value.keys.all? do |key|
+          key.is_a?(String) || key.is_a?(Symbol)
+        end
+        raise ArgumentError, "duplicate normalized identity key" unless value.keys.map(&:to_s).uniq.size == value.size
+
+        value.keys.sort_by(&:to_s).to_h { |key| [key.to_s, canonical_value(value[key])] }.freeze
+      end
+
+      private
+
+      def canonical_path(path)
+        expanded = File.expand_path(path, @root)
+        return File.realpath(expanded) if File.exist?(expanded)
+
+        parent = File.dirname(expanded)
+        File.join(canonical_path(parent), File.basename(expanded))
+      end
+
+      def output_overlap_issues
+        paths = required_files.map(&:first) + MANIFESTS.map { |name| File.join(@root, name) } +
+                DataInputs.files(@root, extra: @config["fingerprint_extra"])
+        outputs = %w[json_report html_report].filter_map { |key| @config.fetch(key) }
+                                             .map { |path| canonical_path(path) }
+        issues = outputs.filter_map do |path|
+          if path.end_with?(".rb") || paths.include?(path) || File.directory?(path) || data_input?(path)
+            "output overlaps input: #{display_path(path)}"
+          end
+        end
+        issues.concat(cache_overlap_issues(paths))
+        issues
+      end
+
+      def cache_overlap_issues(paths)
+        cache = canonical_path(@config["cache_dir"])
+        protected = [@root] + %w[app lib spec test/fixtures].map { |name| File.join(@root, name) } + paths
+        inside = protected.any? do |path|
+          path == cache || path.start_with?("#{cache}/") || (path != @root && cache.start_with?("#{path}/"))
+        end
+        overlaps = inside || data_input?(cache)
+        overlaps ? ["cache directory overlaps inputs: #{display_path(cache)}"] : []
+      end
+
+      # Declared fixture, schema or config input, or a path inside a fixture tree.
+      def data_input?(path)
+        DataInputs.match?(@root, path, extra: @config["fingerprint_extra"])
+      end
+
+      def inventory(issues)
+        paths = project_files(issues).to_h { |path| [path, "ruby"] }
+        MANIFESTS.each { |name| paths[File.join(@root, name)] = "manifest" }
+        data_files(issues).each { |path| paths[path] ||= "data" }
+        required = merged_required_files
+        required.each { |path, (kind, _)| paths[path] = kind }
+        paths.map do |path, kind|
+          needed = required.key?(path) ? required[path].last : !%w[manifest data].include?(kind)
+          read_entry(path, kind, needed, issues)
+        end
+      end
+
+      # Fixtures, schema dumps and database config. A pattern with no match is
+      # fine; a listed file that vanishes later shows up as "removed". Like Ruby
+      # files, data reached through a symlink (the file or a directory above it)
+      # is an undeclared boundary: its real path could be an output or lie outside
+      # the project, so the snapshot is incomplete instead of guessing.
+      def data_files(issues)
+        DataInputs.files(@root, extra: @config["fingerprint_extra"]).reject do |path|
+          next false unless symlinked?(path)
+
+          issues << "symlink input: #{display_path(path)}".freeze
+          true
+        end
+      end
+
+      def symlinked?(path)
+        current = @root
+        path.delete_prefix("#{@root}/").split("/").any? { |part| File.symlink?(current = File.join(current, part)) }
+      end
+
+      def merged_required_files
+        required_files.group_by(&:first).transform_values do |entries|
+          roles = entries.map { |_, kind, _| kind }
+          role = (roles - ["extra"]).min || "extra"
+          [role, entries.any? { |_, _, needed| needed }]
+        end
+      end
+
+      # Walk without following symlink directories. A project symlink is an
+      # undeclared dependency boundary, not a silently omitted source tree.
+      def project_files(issues, directory = @root)
+        Dir.children(directory).sort.flat_map do |name|
+          path = File.join(directory, name)
+          next [] if excluded?(path, name)
+
+          if File.symlink?(path)
+            issues << "symlink input: #{display_path(path)}".freeze
+            next []
+          end
+          next project_files(issues, path) if File.directory?(path)
+
+          File.file?(path) && path.end_with?(".rb") ? [path] : []
+        end
+      rescue SystemCallError
+        issues << "unreadable directory: #{display_path(directory)}".freeze
+        []
+      end
+
+      def excluded?(path, name)
+        EXCLUDED_DIRECTORIES.include?(name) || path == canonical_path(@config["cache_dir"]) ||
+          %w[json_report html_report].filter_map { |key| @config.fetch(key) }.any? do |output|
+            path == canonical_path(output)
+          end
+      end
+
+      def required_files
+        paths = %w[require hooks].flat_map do |key|
+          @config[key].map { |file| [resolve(file), key == "hooks" ? "hook" : "boot", true] }
+        end
+        paths += @config["sources"].reject { |entry| entry == "builtin" }.map do |entry|
+          [resolve(entry.partition(":").first), "source_plugin", true]
+        end
+        paths + @extra_files.map { |path, needed| [path, "extra", needed] }
+      end
+
+      def resolve(file)
+        path = File.expand_path(file, @root)
+        return path if File.exist?(path) || File.extname(path) == ".rb"
+        return "#{path}.rb" if File.exist?("#{path}.rb")
+
+        path
+      end
+
+      def read_entry(path, kind, required, issues)
+        name = display_path(path).freeze
+        unless File.exist?(path)
+          issues << "missing required input: #{name}".freeze if required
+          return Entry.new(path: name, kind: kind.freeze, state: "missing", sha256: nil, required: required)
+        end
+        Entry.new(path: name, kind: kind.freeze, state: "present", sha256: Digest::SHA256.file(path).hexdigest.freeze,
+                  required: required)
+      rescue SystemCallError, IOError
+        issues << "unreadable input: #{name}".freeze
+        Entry.new(path: name, kind: kind.freeze, state: "unreadable", sha256: nil, required: required)
+      end
+
+      def display_path(path)
+        path.start_with?("#{@root}/") ? path.delete_prefix("#{@root}/") : "external:#{path}"
+      end
+
+      def changes_between(previous, current)
+        before = previous.inventory.to_h { |entry| [entry.path, entry] }
+        after = current.inventory.to_h { |entry| [entry.path, entry] }
+        changes = (before.keys | after.keys).sort.filter_map do |path|
+          next if before[path] == after[path]
+
+          Change.new(path: path.freeze, reason: change_reason(before[path], after[path]))
+        end
+        if previous.settings_digest != current.settings_digest
+          changes << Change.new(path: "settings",
+                                reason: "changed")
+        end
+        changes << Change.new(path: "runtime", reason: "changed") if previous.runtime_digest != current.runtime_digest
+        changes
+      end
+
+      def change_reason(before, after)
+        return "added" unless before
+        return "removed" unless after
+        return "unreadable" if after.state == "unreadable"
+
+        "changed"
+      end
+
+      def canonical(value)
+        self.class.canonical_value(value)
+      end
+
+      def hash_value(value)
+        Digest::SHA256.hexdigest(JSON.generate(canonical(value))).freeze
+      end
+    end
+  end
+end

data/lib/saboteur/engine/scheduler.rb

@@ -7,11 +7,10 @@ module Saboteur
     # unit of work parallel workers will share out.
     #
     # Order of business: skip what cannot be run (refinements, not loaded,
-    # shadowed, no covering test); coarse mutants; fine mutants only if no
-    # coarse mutant survived; then check every kill and timeout against the
-    # unchanged method (VerdictCheck). Each mutant runs only the tests that
-    # executed its edit, likeliest killers first, with a timeout from those
-    # tests' recorded durations.
+    # shadowed, no covering test); coarse mutants; all eligible fine mutants;
+    # then check every kill and timeout against the unchanged method
+    # (VerdictCheck). Each mutant runs only the tests that executed its edit,
+    # likeliest killers first, with a timeout from their recorded durations.
     class Scheduler
       # A subject to run, with what its mutants need. killers counts the
       # tests that killed earlier mutants of this subject; slowdown is how
@@ -45,7 +44,7 @@ module Saboteur
         reused = all_reused(plan, candidates)
         return reused if reused
 
-        results = run_candidates(plan, candidates) do |mutation, text|
+        results = run_candidates(candidates) do |mutation, text|
           reuse(plan, mutation, text) || execute(plan, mutation, text)
         end
         checked(subject, results)
@@ -86,21 +85,13 @@ module Saboteur
         return nil unless @cache
 
         catch(:must_run) do
-          run_candidates(plan, candidates) { |mutation, text| reuse(plan, mutation, text) || throw(:must_run) }
+          run_candidates(candidates) { |mutation, text| reuse(plan, mutation, text) || throw(:must_run) }
         end
       end
 
-      def run_candidates(plan, candidates, &run_one)
+      def run_candidates(candidates, &run_one)
         coarse, fine = candidates.partition { |mutation, _| mutation.coarse }
         results = coarse.map { |mutation, text| run_one.call(mutation, text) }
-        # A surviving coarse mutant means nothing checks the body, so the fine
-        # mutants would only add noise. Not so when a rescue or else can
-        # return a value of its own: fine mutants that make the body raise
-        # can still be caught.
-        if results.any?(&:survived?) && !plan.subject.recovers?
-          return results + skip_all(fine, plan.subject, "coarse mutant survived", covered_by: plan.tests)
-        end
-
         results + fine.map { |mutation, text| run_one.call(mutation, text) }
       end
 

data/lib/saboteur/engine/suite_files.rb

@@ -3,6 +3,7 @@
 
 require "digest"
 require "shellwords"
+require_relative "data_inputs"
 
 module Saboteur
   class Engine
@@ -22,7 +23,7 @@ module Saboteur
       end
 
       def files
-        (shared_spec_files + boot_and_hook_files + option_files + required_by_options).uniq.sort
+        (shared_spec_files + boot_and_hook_files + option_files + required_by_options + data_files).uniq.sort
       end
 
       def digest
@@ -33,6 +34,12 @@ module Saboteur
 
       private
 
+      # Fixtures, schema dumps and database config: not Ruby, but they change
+      # what the tests see, so a stale cache must not survive an edit to them.
+      def data_files
+        DataInputs.files(@root, extra: @config["fingerprint_extra"])
+      end
+
       def shared_spec_files
         Dir.glob("spec/**/*.rb", base: @root).reject { |file| file.end_with?("_spec.rb") }
            .map { |file| File.join(@root, file) }

data/lib/saboteur/engine/verdict_check.rb

@@ -63,12 +63,14 @@ module Saboteur
       end
 
       def checked(result, failing_runs, failing)
+        return result if result.reused?
+
         if named_kill?(result) && failing_runs.key?(sequence(result))
           why = failing_runs[sequence(result)]
           result.as_error("killing test #{result.killed_by.first} also fails with the method unchanged" \
-                          "#{": #{why}" if why}")
+                          "#{": #{why}" if why}", rejected_kill: true)
         elsif failing.include?(result)
-          result.as_error("tests also fail with the method unchanged")
+          result.as_error("tests also fail with the method unchanged", rejected_kill: true)
         else
           result
         end