saboteur 0.8.0 → 0.8.1

data/lib/saboteur/engine/baseline_guard.rb

@@ -24,7 +24,7 @@ module Saboteur
       # coverage build when the cache is cold, so the first timed pass can
       # price the rest (#260).
       def initialize(config:, integration:, hooks:, supervisor:, diagnostics:, full_passes: 2, between_passes: nil,
-                     timeout_cap: nil)
+                     timeout_cap: nil, run_started: nil)
         @config = config
         @integration = integration
         @hooks = hooks
@@ -33,6 +33,7 @@ module Saboteur
         @full_passes = full_passes
         @between_passes = between_passes
         @timeout_cap = timeout_cap
+        @run_started = run_started
         @completed_passes = 0
       end
 
@@ -51,10 +52,7 @@ module Saboteur
           started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
           data = check(number)
           announce_first_pass_cost(number, started)
-          unless data["passed"] && data["failed"].empty?
-            refuse(number,
-                   with_hint("the suite failed: #{Array(data['failed']).join(', ')}", data))
-          end
+          refuse_suite_failure(number, data) unless data["passed"] && data["failed"].empty?
           executed = data["executed"]
           refuse(number, "executed tests do not match the loaded suite") unless
             executed.sort == expected.sort
@@ -67,6 +65,16 @@ module Saboteur
 
       private
 
+      def refuse_failed_suite(number, data)
+        outside = data["failed"].empty?
+        reason = if outside
+                   "the suite errored outside any example; see the log tail"
+                 else
+                   "the suite failed: #{data['failed'].join(', ')}"
+                 end
+        refuse(number, with_hint(reason, data), tail: outside)
+      end
+
       # A spent --max-duration budget skips the remaining passes - including
       # the first, when boot alone already spent it (#245).
       def budget_spent?(_index)
@@ -95,9 +103,10 @@ module Saboteur
 
         coverage_pending = @full_passes > @config["baseline_passes"]
         remaining = @full_passes - number - (coverage_pending ? 1 : 0)
+        elapsed = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - started).round
+        warn_budget_projection(elapsed, remaining + (coverage_pending ? 1 : 0))
         return if remaining.zero? && !coverage_pending
 
-        elapsed = (Process.clock_gettime(Process::CLOCK_MONOTONIC) - started).round
         work = []
         work << "the remaining #{remaining} full #{remaining == 1 ? 'pass' : 'passes'}" if remaining.positive?
         work << "the coverage map build" if coverage_pending
@@ -106,6 +115,28 @@ module Saboteur
                             "#{work.join(' and ')} at that rate")
       end
 
+      # The first timed pass also prices the run against --max-duration:
+      # boot and this pass are spent, the remaining passes and a cold
+      # coverage build cost about that much again at that rate, and only
+      # what is left feeds mutants. Warn while a Ctrl-C is still cheap -
+      # the refusal only fires once the coverage build is unaffordable
+      # outright (#637).
+      def warn_budget_projection(pass_elapsed, remaining_passes)
+        budget = @config["max_duration"]
+        return unless budget && @run_started
+
+        spent = Process.clock_gettime(Process::CLOCK_MONOTONIC) - @run_started
+        projected = spent + (pass_elapsed * remaining_passes)
+        mutants_get = budget - projected
+        return if mutants_get >= pass_elapsed
+
+        verdict = mutants_get <= 0 ? "exceeds" : "barely fits"
+        @diagnostics.warn("projected baseline+coverage ~#{projected.round}s #{verdict} " \
+                          "--max-duration #{budget.round}s; mutants would get " \
+                          "~#{format('%g', [mutants_get, 0].max.round(1))}s. Raise --max-duration, pass fewer " \
+                          "--baseline-passes, or narrow the scope")
+      end
+
       # An admitted pass still gets only the time left in the run budget:
       # without the cap it would overrun a spent --max-duration by its
       # whole coverage_timeout.
@@ -209,6 +240,41 @@ module Saboteur
         writer.close
       end
 
+      # A failed unchanged suite never runs mutants: warn first when the
+      # failure carries the Minitest signature (#626), then refuse.
+      def refuse_suite_failure(number, data)
+        warn_minitest_signature(number)
+        refuse_failed_suite(number, data)
+      end
+
+      # Minitest::Spec suites in *_spec.rb clothing load under the RSpec
+      # integration and then fail the baseline with NoMethodError for
+      # Minitest-only methods (#626): the refusal still reads "fix the
+      # suite", so warn what the signature actually points at. It stays a
+      # warning: an RSpec suite can require minitest for a helper and
+      # fail for its own reason, and a heuristic refusal would
+      # false-positive there.
+      def warn_minitest_signature(number)
+        lines = log_lines(number)
+        errors = lines.grep(/NoMethodError/)
+        return if errors.empty? || !spec_helper_requires_minitest?
+
+        symptom = (lines.find { |line| line.include?("undefined method") } || errors.first).strip
+        @diagnostics.warn("the baseline failure looks like a Minitest suite running under RSpec, not a " \
+                          "broken RSpec suite: the log shows #{errors.size} " \
+                          "NoMethodError#{'s' if errors.size > 1} (for example: #{symptom.slice(0, EXCERPT_WIDTH)}) " \
+                          "and spec/spec_helper.rb requires minitest. saboteur is RSpec-only, so a " \
+                          "Minitest suite cannot be mutation tested with it.")
+      end
+
+      # The framework check behind the warning: spec_helper is the
+      # suite's own declaration of what it runs on.
+      def spec_helper_requires_minitest?
+        File.read(File.join(@config.root, "spec", "spec_helper.rb")).match?(/^\s*require\s+["']minitest/)
+      rescue SystemCallError
+        false
+      end
+
       # A child that recognises its own failure shape (an empty sqlite
       # :memory: database after the fork, #387) says how to fix it.
       def with_hint(reason, data)
@@ -230,9 +296,9 @@ module Saboteur
         "the suite passed but left #{count} child #{count == 1 ? 'process' : 'processes'} behind: #{detail}"
       end
 
-      def refuse(number, reason, excerpt: true)
+      def refuse(number, reason, excerpt: true, tail: false)
         raise Error, "baseline check #{number} failed at seed #{@config['seed']}: #{reason}. " \
-                     "#{failure_excerpt(number) if excerpt}See the full log at #{log_path(number)}. " \
+                     "#{failure_excerpt(number, tail: tail) if excerpt}See the full log at #{log_path(number)}. " \
                      "Fix the suite or its setup, then run saboteur again with the same seed. " \
                      "No mutants were started."
       end
@@ -240,11 +306,11 @@ module Saboteur
       # The first lines of the failure, inline, so the cause is readable
       # without opening the log: RSpec's "Failures:" section when the log has
       # one, otherwise the last lines of the log.
-      def failure_excerpt(number)
+      def failure_excerpt(number, tail: false)
         lines = log_lines(number)
         return "" if lines.empty?
 
-        start = lines.index { |line| line.start_with?("Failures:") }
+        start = lines.index { |line| line.start_with?("Failures:") } unless tail
         shown = start ? lines[start, EXCERPT_LINES] : lines.last(EXCERPT_LINES)
         "The log says:\n#{shown.map { |line| "  #{line.slice(0, EXCERPT_WIDTH)}" }.join("\n")}\n"
       end

data/lib/saboteur/engine/boot.rb

@@ -66,7 +66,9 @@ module Saboteur
         @rails = rails = Frameworks::Rails.new(@config, @hooks) if @config["rails"]
         rails&.before_boot
         @hooks.run(:before_boot)
-        add_spec_to_load_path if @config["rails"]
+        add_spec_to_load_path
+        # Helpers may configure RSpec before the integration loads specs.
+        Integration::RSpec.new(@config).require_framework if @config["integration"] == "rspec"
         @config["require"].each { |file| require File.expand_path(file, @root) }
         integration = Integration.fetch(@config["integration"]).new(@config)
         integration.setup
@@ -78,8 +80,10 @@ module Saboteur
       private
 
       # rspec puts spec/ on the load path, so a boot file under spec/ (a
-      # dummy app's rails_helper, say) can require its siblings. Match
-      # that, or the same require list fails to load.
+      # dummy app's rails_helper, or a non-Rails gem's spec_helper that
+      # requires its siblings) can require its siblings. Match that for
+      # every project - a non-Rails gem does not add spec/ itself (#615) -
+      # or the same require list fails to load.
       def add_spec_to_load_path
         path = File.join(@root, "spec")
         $LOAD_PATH.unshift(path) unless $LOAD_PATH.include?(path)

data/lib/saboteur/engine/bytecode_equivalence.rb

@@ -42,11 +42,27 @@ module Saboteur
 
       def fingerprint(text, frozen)
         options = { frozen_string_literal: frozen }
-        strip_positions(RubyVM::InstructionSequence.compile(text, nil, nil, 1, options).to_a)
+        iseq = warnings_silenced do
+          RubyVM::InstructionSequence.compile(text, "saboteur/bytecode-equivalence", nil, 1, options)
+        end
+        strip_positions(iseq.to_a)
       rescue SyntaxError, StandardError
         nil
       end
 
+      # Mutants compile one by one, and generated bodies (body_nil,
+      # statement_removal) trip Ruby's own void-context warnings, so a host
+      # suite running with -w gets one line per mutant flooding stderr
+      # (#592, #656). The check is internal: silence the compiler. A mutant
+      # that does not parse still fails the compile and runs.
+      def warnings_silenced
+        saved = $VERBOSE
+        $VERBOSE = nil
+        yield
+      ensure
+        $VERBOSE = saved
+      end
+
       # Structural equality that never coerces: an Integer is not a Float,
       # and +0.0 is not -0.0 (1.0 / +0.0 and 1.0 / -0.0 are different
       # infinities), which eql? alone would not tell apart.

data/lib/saboteur/engine/candidate_selection.rb

@@ -66,6 +66,7 @@ module Saboteur
       # Load-only code is not "no coverage": it ran, just never inside a
       # test, and no forked test can re-run it (see CoverageMap::RAN_AT_LOAD).
       def skip_reason_for(subject)
+        return Selection::CoverageMap::PRELOADED if @map.preloaded?(subject.file)
         return "no coverage" unless @map.ran_at_load?(subject.file, subject.coverage_lines)
 
         Selection::CoverageMap::RAN_AT_LOAD

data/lib/saboteur/engine/coverage_store.rb

@@ -40,10 +40,11 @@ module Saboteur
 
       def fetch(files)
         path = cache_path(files)
+        preloaded = LoadCoverage.preloaded_uninstrumented(files)
         cached = cached_map(files)
-        return refuse_empty_map(cached, files) if cached
+        return refuse_empty_map(cached.with_preloaded(preloaded), files, preloaded) if cached
 
-        map = refuse_empty_map(build(files), files)
+        map = refuse_empty_map(build(files).with_preloaded(preloaded), files, preloaded)
         map.save(path)
         File.write(File.join(@config.path("cache_dir"), "preview.json"),
                    JSON.generate(path: path, fingerprint: RunFingerprint.new(config: @config).snapshot.digest))
@@ -157,9 +158,20 @@ module Saboteur
       # 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)
+      def refuse_empty_map(map, files, preloaded)
         return map if files.empty? || !map.empty_for?(files)
 
+        # A file loaded before the executable's Coverage.start can never be
+        # instrumented, so emptiness there is a setup defect, not untested
+        # code: name it apart from the generic no-coverage refusal.
+        preloaded_empty = preloaded & files.map { |file| Selection::CoverageMap.canonical(file) }
+        if preloaded_empty.any?
+          message = preloaded_message(preloaded_empty)
+          raise Error, message if @config["tests"].empty?
+
+          @diagnostics.warn(message)
+          return map
+        end
         if @config["tests"].empty?
           raise Error, "Coverage recorded nothing in #{files.size} included files during a whole-suite " \
                        "build. No test in the suite may exercise these files, or the setup hid the app " \
@@ -170,6 +182,16 @@ module Saboteur
         map
       end
 
+      def preloaded_message(files)
+        names = files.first(5).map { |file| file.delete_prefix("#{@root}/") }
+        more = files.size > 5 ? ", ..." : ""
+        "#{names.join(', ')}#{more} loaded before saboteur started coverage (a require ran before the " \
+          "executable's Coverage.start - commonly the gemspec requiring the library while bundler/setup " \
+          "evaluates it, or RUBYOPT -r), so no test can ever cover #{files.size > 1 ? 'them' : 'it'}. " \
+          "Let the test suite load these " \
+          "files; a gemspec should require only its version file."
+      end
+
       # Bootsnap is named only when it is loaded: blaming a library the app
       # does not use sends the reader to the wrong place.
       def bootsnap_note

data/lib/saboteur/engine/diagnostics.rb

@@ -74,7 +74,7 @@ module Saboteur
       DiscoveryFailure = Data.define(:file, :reason)
 
       attr_reader :warnings, :invalid_mutations, :generation_events, :omissions, :discovery_failures,
-                  :hazard_suppressions, :inline_suppressions
+                  :hazard_suppressions, :inline_suppressions, :verbose
 
       def initialize(err, verbose: false)
         @err = err

data/lib/saboteur/engine/gated_run.rb

@@ -26,7 +26,9 @@ module Saboteur
       # a gated run keep the hard stop.
       def stop_or_warn_unmapped(guess)
         return if guess.unmatched.empty?
-        raise ConfigError, guess.unmatched_message if !config["since"] || guess.specs.empty? || gated?
+        if !config["since"] || guess.specs.empty? || gated?
+          raise ConfigError, guess.unmatched_message(verbose: @diagnostics.verbose)
+        end
 
         guess.unmatched.each { |file| @diagnostics.announce(guess.unmatched_warning(file)) }
       end

data/lib/saboteur/engine/load_coverage.rb

@@ -32,6 +32,24 @@ module Saboteur
         end
       end
 
+      # Include-listed files that are already loaded yet carry no coverage
+      # instrumentation: something required them before the executable's
+      # Coverage.start (a gemspec requiring the library while bundler/setup
+      # evaluates it, or RUBYOPT -r), so no test can ever be attributed to
+      # them. Read in the parent, where the snapshot still reflects the boot.
+      def self.preloaded_uninstrumented(files, loaded: $LOADED_FEATURES)
+        return [] unless Coverage.state == :suspended
+
+        instrumented = CoverageReads.result(stop: false, clear: false)
+                                    .each_key
+                                    .to_set { |path| Selection::CoverageMap.canonical(path) }
+        loaded_set = loaded.to_set { |path| Selection::CoverageMap.canonical(path) }
+        files.map { |file| Selection::CoverageMap.canonical(file) }
+             .uniq
+             .reject { |file| instrumented.include?(file) }
+             .select { |file| loaded_set.include?(file) }
+      end
+
       # A one-line or endless definition executes its def line even when its
       # body is never called. If any sibling on that physical line is uncalled,
       # discard its ambiguous line evidence rather than crediting every body.

data/lib/saboteur/engine/pipelines.rb

@@ -1,6 +1,8 @@
 # SPDX-License-Identifier: MIT
 # frozen_string_literal: true
 
+require_relative "../execution/test_command_shape"
+
 module Saboteur
   class Engine
     # The two run pipelines: in-process (boot, coverage, workers) and the
@@ -43,6 +45,12 @@ module Saboteur
       def call_external(ignore_list, started)
         @diagnostics.inform("external test command: #{config['test_command']} " \
                             "(serial, no coverage, unsandboxed, mutants applied in a disposable copy)")
+        if Execution::TestCommandShape.multi_file_ruby?(config["test_command"])
+          @diagnostics.warn("the test command hands several test files to one ruby: ruby executes only " \
+                            "the first, so the rest never run and their mutants silently survive (#611) - " \
+                            "use the framework's multi-file form (bin/rails test f1 f2, rspec f1 f2) or a " \
+                            "shell loop (for f in ...; do ruby \"$f\" || exit 1; done)")
+        end
         files = config.included_files
         subjects, scope = select_subjects(files)
         results = subjects.empty? ? [] : mutate_external(subjects, scope, ignore_list)

data/lib/saboteur/engine/run_budget.rb

@@ -35,8 +35,11 @@ module Saboteur
 
       # Absolute monotonic deadline shared with the schedulers (forked
       # workers inherit it): a subject's remaining mutants stop once it
-      # passes, so the overshoot after a spent budget stays under one
-      # mutant deadline.
+      # passes. New mutation work never overshoots more than the fork in
+      # flight; a subject the deadline cut mid-list still confirms the
+      # kills it already measured (#588), and those checks and retries
+      # fork uncapped - the overshoot is bounded by the subject's
+      # distinct killing sequences times their full timeout.
       def budget_deadline
         config["max_duration"] && (@run_started + config["max_duration"])
       end

data/lib/saboteur/engine/sandbox_policy.rb

@@ -39,8 +39,7 @@ module Saboteur
         # same line twice (D's review, #178).
         unless @sandbox_note_given
           @sandbox_note_given = true
-          @diagnostics.warn("sandbox is on but #{self.class.sandbox_gap(abi)}; children run with the hazard guard " \
-                            "and canary only")
+          @diagnostics.warn(degraded_note(abi))
         end
         nil
       end
@@ -55,11 +54,30 @@ module Saboteur
       end
 
       def self.sandbox_gap(abi)
-        return "this kernel lacks Landlock (needs Linux 6.2+)" if abi.zero?
+        if abi.zero?
+          # Landlock is Linux-only: on macOS there is no kernel to upgrade,
+          # so name the platform instead of a Linux version (#667).
+          return "macOS has no Landlock" if Execution::Seatbelt.darwin?
+
+          return "this kernel lacks Landlock (needs Linux 6.2+)"
+        end
 
         "this kernel's Landlock ABI is #{abi} but ABI 3 (Linux 6.2+) is needed to restrict truncate()"
       end
 
+      # The degraded-run note: on macOS the gap is permanent, so point at
+      # the Seatbelt opt-in; on Linux the kernel wording stands alone
+      # (#667). Severity stays a warning - degrading confinement is never
+      # routine.
+      def degraded_note(abi)
+        gap = self.class.sandbox_gap(abi)
+        tail = "children run with the hazard guard and canary only"
+        return "sandbox is on but #{gap}; #{tail}" unless Execution::Seatbelt.darwin?
+
+        "sandbox is on but #{gap}; #{tail} - opt into the macOS sandbox with c.sandbox = \"seatbelt\" " \
+          "(docs/guides/macos-seatbelt-sandbox.md), or set c.sandbox = false to silence this"
+      end
+
       def restrict_hook
         writable = sandbox_writable_dirs
         ->(keep_fds) { Execution::Sandbox.restrict!(writable: writable, keep_fds: keep_fds) }

data/lib/saboteur/engine/scheduler.rb

@@ -64,7 +64,7 @@ module Saboteur
         results = run_candidates(candidates) do |mutation, text|
           reuse(plan, mutation, text) || execute(plan, mutation, text)
         end
-        checked(plan, results)
+        checked(plan, results, truncated: results.size < candidates.size)
       end
 
       # The per-mutant timeout: timeout_factor times what the tests took
@@ -81,14 +81,21 @@ module Saboteur
 
       # Verdicts that did not hold up are warned about once per subject;
       # only checked verdicts are stored for --incremental.
-      # A spent budget admits no check: forking the unchanged run with no
-      # time left would turn genuine kills into fabricated errors and cache
-      # them. Fresh kills stand unverified instead - outside the score,
-      # never cached - and the distribution marks the subject so the run
-      # reports budget-partial.
-      def checked(plan, results)
-        return results.map { |result| unverifiable(result) } if budget_spent?
-
+      # A spent budget admits no check for a subject that finished its
+      # mutants: forking the unchanged run with no time left would turn
+      # genuine kills into fabricated errors and cache them. Fresh kills
+      # stand unverified instead - outside the score, never cached - and
+      # the distribution marks the subject so the run reports
+      # budget-partial.
+      # A subject the budget stopped mid-list is different (#588): its
+      # completed mutants were already measured, so their checks still
+      # run, uncapped - the budget stops new mutation work, not the
+      # confirmation of work already done. The overshoot stays bounded by
+      # the subject's distinct killing sequences.
+      def checked(plan, results, truncated: false)
+        return results.map { |result| unverifiable(result) } if budget_spent? && !truncated
+
+        @confirming_truncation = truncated
         subject = plan.subject
         check = VerdictCheck.new(run_unchanged: unchanged_runner(subject, plan),
                                  baseline_timeout: @config["baseline_timeout"])
@@ -101,6 +108,8 @@ module Saboteur
           @diagnostics.warn("#{subject.id}: #{overturned} verdict(s) failed with the method unchanged")
         end
         final
+      ensure
+        @confirming_truncation = false
       end
 
       # A kill rejected because its covering examples fail with the method
@@ -111,10 +120,12 @@ module Saboteur
       # mutant's run on the same examples. Otherwise the error stays.
       #
       # Cost bound: at most two extra forks per rejected kill, the unchanged
-      # prefix run and one mutant run. Both spend --max-duration like every
-      # other fork: neither starts once the budget is spent, and neither gets
-      # more than the time left. A retry the budget stops is unverified, not
-      # an error or a kill. Keep this bound if the retry ever grows.
+      # prefix run and one mutant run. Ordinarily both spend --max-duration
+      # like every other fork: neither starts once the budget is spent, and
+      # neither gets more than the time left. A retry the budget stops is
+      # unverified, not an error or a kill. The exception is a truncated
+      # subject (#588): its completed kills still retry, at the full
+      # timeout. Keep this bound if the retry ever grows.
       def retried_in_defined_order(plan, result)
         return result unless result.rejected_kill? && !result.reused? && result.covered_by.any?
 
@@ -129,10 +140,10 @@ module Saboteur
       end
 
       def rerun_in_prefix(plan, result, tests)
-        return result.as_unverified(BUDGET_RETRY_REASON) if budget_spent?
+        return result.as_unverified(BUDGET_RETRY_REASON) if budget_spent? && !@confirming_truncation
 
         full = timeout_for(tests, plan.slowdown)
-        capped = budget_capped(full)
+        capped = @confirming_truncation ? full : budget_capped(full)
         outcome = @runner.run(subject: plan.subject, text: result.mutated_source, test_ids: tests,
                               timeout: capped, mutation: result.mutation, eval_prefix: eval_prefix(plan))
         return result.as_unverified(BUDGET_RETRY_REASON) if outcome.status == :timeout && capped < full
@@ -150,11 +161,11 @@ module Saboteur
       # the check never got its answer (#296).
       def unchanged_runner(subject, plan)
         lambda do |tests, timeout|
-          if budget_spent?
+          if budget_spent? && !@confirming_truncation
             Execution::Runner::Outcome.new(status: :unverified, runtime: 0.0,
                                            message: "the --max-duration budget is spent")
           else
-            capped = budget_capped(timeout)
+            capped = @confirming_truncation ? timeout : budget_capped(timeout)
             outcome = @runner.run(subject: subject, text: subject.source, test_ids: tests, timeout: capped,
                                   eval_prefix: eval_prefix(plan))
             note_leftovers(subject, "verdict check", outcome)
@@ -238,17 +249,14 @@ module Saboteur
         [@config["timeout_factor"] * runtime, @config["timeout_min"]].max
       end
 
-      # What a subject no test ran gets. Code that only ran while the app
-      # loaded is not "no coverage" - it ran - but no forked test can re-run
-      # it, so it gets its own status, out of the score, with a hint.
+      # What a subject no test ran gets. Load-only code is not "no coverage":
+      # it ran, but no forked test can re-run it, so it gets its own status.
       def unloadable(candidates, subject, line_numbers = nil)
+        return skip_all(candidates, subject, Selection::CoverageMap::PRELOADED) if @map.preloaded?(subject.file)
         return skip_all(candidates, subject, "no coverage") unless
           @map.ran_at_load?(subject.file, line_numbers || subject.coverage_lines)
 
-        candidates.map do |mutation, text|
-          MutantResult.new(subject: subject, mutation: mutation, status: :ran_at_load, mutated_source: text,
-                           reason: Selection::CoverageMap::RAN_AT_LOAD)
-        end
+        load_time_results(candidates, subject)
       end
 
       # A def-time macro's only callers ran while the app loaded: the

data/lib/saboteur/engine/selection_announcement.rb

@@ -10,10 +10,15 @@ module Saboteur
     module SelectionAnnouncement
       private
 
+      # A --since diff with no changed source file (a spec-only or docs-only
+      # change) yields zero subjects, so the suite never runs: say there is
+      # nothing to test rather than promise a whole-suite run that does not
+      # happen (#607).
       def selection_message(guess)
-        if guess.changed.zero?
-          target = config["since"] ? "no changed source file" : "no source file"
-          "inferred specs: #{target} to infer a spec for, so the whole suite runs"
+        if guess.changed.zero? && config["since"]
+          "inferred specs: no changed source file to infer a spec for, so there is nothing to test"
+        elsif guess.changed.zero?
+          "inferred specs: no source file to infer a spec for, so the whole suite runs"
         elsif guess.specs.empty?
           guess.no_specs_message(since: config["since"])
         else