rspec-mergify 0.2.0-aarch64-linux → 0.4.0-aarch64-linux

data/lib/mergify/rspec/configuration.rb

@@ -1,20 +1,33 @@
 # frozen_string_literal: true
 
 require 'set'
+require_relative 'test_selection'
 
 module Mergify
   module RSpec
-    # Registers RSpec hooks for quarantine and flaky detection, and adds the
+    # Registers RSpec hooks for quarantine and flaky detection, and attaches the
     # Mergify Test Insights formatter when running inside CI.
+    # rubocop:disable-next Metrics/ModuleLength
     module Configuration
+      QUARANTINE_MESSAGE = 'Test is quarantined from Mergify Test Insights'
+
       module_function
 
-      # rubocop:disable Metrics/MethodLength,Metrics/BlockLength,Metrics/AbcSize
+      # rubocop:disable-next Metrics/MethodLength,Metrics/BlockLength,Metrics/AbcSize
       # rubocop:disable-next Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
       def setup!
         ::RSpec.configure do |config|
-          # Add formatter when in CI
-          config.add_formatter(Mergify::RSpec::Formatter) if Utils.in_ci?
+          # Registered before the formatter's hook so that it runs after it --
+          # each `prepend_before` goes to the front: the formatter has to be
+          # attached already for the run's report and verdict to see what the
+          # selection did.
+          config.prepend_before(:suite) { Configuration.select_examples } if Utils.in_ci?
+
+          # Attached to the reporter once the suite starts, rather than added with
+          # `add_formatter`: RSpec only sets up its default formatter when no
+          # other was added, so adding this one took the progress output and the
+          # summary line away from every suite that had not chosen a format.
+          config.prepend_before(:suite) { Configuration.attach_formatter(config) } if Utils.in_ci?
 
           # Flaky detection: prepare session with all example IDs
           config.before(:suite) do
@@ -37,81 +50,163 @@ module Mergify
 
           # Flaky detection: rerun tests within budget
           config.around(:each) do |example|
-            ci = Mergify::RSpec.ci_insights
-            fd = ci&.flaky_detector
-
-            example.run
-
-            # Feed metrics from the initial run so the detector can evaluate
-            if fd
-              run_time = example.execution_result.run_time || 0.0
-              status = example.execution_result.status
-              fd.fill_metrics_from_report(example.id, 'setup', 0.0, status)
-              fd.fill_metrics_from_report(example.id, 'call', run_time, status)
-              fd.fill_metrics_from_report(example.id, 'teardown', 0.0, status)
-            end
-
-            next unless fd&.rerunning_test?(example.id)
+            fd = Mergify::RSpec.ci_insights&.flaky_detector
+            fd ? Configuration.run_detecting_flakiness(example, fd) : example.run
+          end
 
-            # Mark as flaky detection candidate (even if too slow to rerun)
-            example.metadata[:mergify_flaky_detection] = true
-            example.metadata[:mergify_new_test] = true if fd.mode == 'new'
+          # Quarantine: override failed quarantined test results. The failure is
+          # noted for flaky detection first, which would otherwise take a
+          # quarantined attempt that failed for one that passed.
+          config.after(:each) do |example|
+            next unless example.metadata[:mergify_quarantined] && example.exception
 
-            fd.set_test_deadline(example.id)
-            next if fd.test_too_slow?(example.id)
+            example.metadata[:mergify_quarantined_failure] = true
+            example.instance_variable_set(:@exception, nil)
+            example.execution_result.status = :pending
+            example.execution_result.pending_message = QUARANTINE_MESSAGE
+          end
+        end
+      end
 
-            distinct_outcomes = Set.new
-            distinct_outcomes.add(example.execution_result.status) if example.execution_result.status
+      # Fingerprint what this process is about to run, ask Mergify whether part
+      # of it is enough, and remove the rest.
+      #
+      # A `before(:suite)` hook, because that is the first moment RSpec has both
+      # loaded the spec files and applied its filters, and the last one before
+      # an example group starts. What each group runs is read from
+      # `RSpec.world.filtered_examples`, which RSpec memoized while counting the
+      # run; narrowing those lists is what deselects.
+      # rubocop:disable-next Metrics/MethodLength,Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+      def select_examples
+        ci = Mergify::RSpec.ci_insights
+        return unless ci
+
+        groups = ::RSpec.world.example_groups.flat_map(&:descendants)
+        ids = groups.flat_map { |group| ::RSpec.world.filtered_examples[group] }.map(&:id)
+        ci.on_examples_collected(ids)
+
+        begin
+          keep = ci.test_selection&.resolve(ids)
+        rescue TestSelectionRefused => e
+          ci.on_selection_resolved(0)
+          return refuse(e.message)
+        end
 
-            rerun_count = 0
-            # Use a null reporter to prevent reruns from being reported as
-            # individual failures. The final outcome is set after the loop.
-            null_reporter = ::RSpec::Core::NullReporter
+        deselect(groups, keep) if keep
+        ci.on_selection_resolved(keep ? ids.count { |id| keep.include?(id) } : ids.size)
+      rescue StandardError => e
+        # This runs on every CI run, opted in or not, and RSpec would answer a
+        # raise here by running nothing: a fault of this gem must cost the run
+        # its reduction, never its tests.
+        ::RSpec.configuration.error_stream.puts(
+          "Mergify Test Selection failed, so the full suite runs: #{e.class}: #{e.message}"
+        )
+      end
 
-            until example.metadata[:is_last_rerun]
-              example.metadata[:is_last_rerun] = fd.last_rerun_for_test?(example.id)
+      # Stop the run before any example, the way RSpec stops one whose suite
+      # hook failed -- nothing runs, the exit code is red, and the summary
+      # counts an error outside of examples -- but with the server's
+      # explanation alone. Raised from the hook, the same failure is printed
+      # under a "Failure/Error:" header pointing at a line of this gem, which
+      # only buries the explanation.
+      def refuse(message)
+        ::RSpec.configuration.error_stream.puts("\n#{message}\n")
+        ::RSpec.world.wants_to_quit = true
+        reporter = ::RSpec.configuration.reporter
+        count = reporter.instance_variable_get(:@non_example_exception_count)
+        reporter.instance_variable_set(:@non_example_exception_count, count + 1) if count.is_a?(Integer)
+      end
 
-              # Reset example state for rerun
-              example.instance_variable_set(:@exception, nil)
-              if example.example_group_instance
-                memoized = example.example_group_instance.instance_variable_get(:@__memoized)
-                if memoized.respond_to?(:clear)
-                  memoized.clear
-                elsif memoized
-                  # RSpec >= 3.12 uses ThreadsafeMemoized which wraps an internal hash
-                  inner = memoized.instance_variable_get(:@memoized)
-                  inner&.clear
-                end
-              end
+      # A group left with no example runs none of its `before(:context)`
+      # hooks: RSpec decides that from these same lists, once the group starts.
+      def deselect(groups, keep)
+        groups.each do |group|
+          ::RSpec.world.filtered_examples[group] =
+            ::RSpec.world.filtered_examples[group].select { |example| keep.include?(example.id) }
+        end
+      end
 
-              example.run(example.example_group_instance, null_reporter)
+      # The reporter has sent `start` by the time suite hooks run, so the
+      # formatter is handed the same notification directly.
+      def attach_formatter(config)
+        formatter = Formatter.new(config.output_stream)
+        formatter.start(::RSpec::Core::Notifications::StartNotification.new(::RSpec.world.example_count, 0))
+        config.reporter.register_listener(formatter, *Formatter::NOTIFICATIONS)
+      end
 
-              # Feed rerun metrics so budget/deadline tracking stays accurate
-              rerun_time = example.execution_result.run_time || 0.0
-              rerun_status = example.execution_result.status
-              fd.fill_metrics_from_report(example.id, 'call', rerun_time, rerun_status)
+      # `example` is the Procsy an around hook is handed, and the example has no
+      # result yet: RSpec records its status and run time in `Example#finish`,
+      # once every around hook has returned. So each attempt is timed here, and
+      # its outcome read off the exception it left behind.
+      # rubocop:disable-next Metrics/AbcSize
+      def run_detecting_flakiness(example, detector)
+        status, duration = run_attempt(example)
+        detector.fill_metrics_from_report(example.id, 'setup', 0.0, status)
+        detector.fill_metrics_from_report(example.id, 'call', duration, status)
+        detector.fill_metrics_from_report(example.id, 'teardown', 0.0, status)
+        return unless detector.rerunning_test?(example.id)
+
+        # Mark as flaky detection candidate (even if too slow to rerun)
+        example.metadata[:mergify_flaky_detection] = true
+        example.metadata[:mergify_new_test] = true if detector.mode == 'new'
+
+        detector.set_test_deadline(example.id)
+        return if detector.test_too_slow?(example.id)
+
+        rerun(example, detector, status)
+      end
 
-              distinct_outcomes.add(rerun_status)
-              rerun_count += 1
-            end
+      # Which attempt decides the result is pytest-mergify's rule: in 'new' mode
+      # any failure fails the test, so a new flaky test cannot be merged; in
+      # 'unhealthy' mode the reruns only learn, and the first attempt stands.
+      # rubocop:disable-next Metrics/MethodLength,Metrics/AbcSize
+      def rerun(example, detector, initial_status)
+        initial_exception = example.exception
+        first_failure = initial_exception
+        outcomes = Set[initial_status]
+        rerun_count = 0
+
+        until example.metadata[:is_last_rerun]
+          example.metadata[:is_last_rerun] = detector.last_rerun_for_test?(example.id)
+          reset_for_rerun(example)
+
+          status, duration = run_attempt(example)
+          detector.fill_metrics_from_report(example.id, 'call', duration, status)
+          outcomes << status
+          first_failure ||= example.exception
+          rerun_count += 1
+        end
 
-            is_flaky = distinct_outcomes.include?(:passed) &&
-                       distinct_outcomes.include?(:failed)
-            example.metadata[:mergify_flaky] = true if is_flaky
-            example.metadata[:mergify_rerun_count] = rerun_count
-          end
+        example.metadata[:mergify_flaky] = true if outcomes.include?(:passed) && outcomes.include?(:failed)
+        example.metadata[:mergify_rerun_count] = rerun_count
+        final_exception = detector.mode == 'new' ? first_failure : initial_exception
+        example.example.instance_variable_set(:@exception, final_exception)
+      end
 
-          # Quarantine: override failed quarantined test results
-          config.after(:each) do |example|
-            next unless example.metadata[:mergify_quarantined] && example.exception
+      # Runs what the around hook wraps -- the before and after hooks included
+      # -- and answers its outcome and duration in seconds.
+      def run_attempt(example)
+        started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        example.run
+        duration = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started
+        failed = example.exception || example.metadata.delete(:mergify_quarantined_failure)
+        [failed ? :failed : :passed, duration]
+      end
 
-            example.instance_variable_set(:@exception, nil)
-            example.execution_result.status = :pending
-            example.execution_result.pending_message = 'Test is quarantined from Mergify Test Insights'
-          end
+      # The exception lives on the example itself, not on the Procsy: setting
+      # it there would leave RSpec to fold every attempt's failure into one.
+      def reset_for_rerun(example)
+        example.example.instance_variable_set(:@exception, nil)
+        return unless example.example_group_instance
+
+        memoized = example.example_group_instance.instance_variable_get(:@__memoized)
+        if memoized.respond_to?(:clear)
+          memoized.clear
+        elsif memoized
+          # RSpec >= 3.12 uses ThreadsafeMemoized which wraps an internal hash
+          memoized.instance_variable_get(:@memoized)&.clear
         end
       end
-      # rubocop:enable Metrics/MethodLength,Metrics/BlockLength,Metrics/AbcSize
     end
   end
 end

data/lib/mergify/rspec/flaky_detection.rb

@@ -126,8 +126,7 @@ module Mergify
       def set_test_deadline(test_id, timeout: nil)
         return unless @metrics.key?(test_id)
 
-        remaining_tests = [remaining_tests_count, 1].max
-        per_test_budget = remaining_budget / remaining_tests
+        per_test_budget = next_test_share
 
         allocated =
           if timeout
@@ -147,11 +146,14 @@ module Mergify
         (metrics.initial_duration * min_exec) > metrics.remaining_time
       end
 
+      # Asked before the rerun it guards. `rerun_count` counts executions, the
+      # initial one included, so the rerun about to start is the last one when
+      # it is the one reaching the cap.
       def last_rerun_for_test?(test_id)
         return false unless @metrics.key?(test_id)
 
         metrics = @metrics[test_id]
-        metrics.will_exceed_deadline? || metrics.rerun_count >= @context['max_test_execution_count']
+        metrics.will_exceed_deadline? || metrics.rerun_count + 1 >= @context['max_test_execution_count']
       end
 
       def test_metrics(test_id)
@@ -198,17 +200,21 @@ module Mergify
         context
       end
 
-      def remaining_budget
-        used = budget_used
-        [@budget - used, 0.0].max
-      end
-
       def budget_used
         @metrics.sum { |_, m| m.total_duration }
       end
 
-      def remaining_tests_count
-        @tests_to_process.count { |id| !@metrics.key?(id) || @metrics[id].deadline.nil? }
+      # What is left of the budget, divided over the tests still waiting for a
+      # share of it. The engine works in milliseconds; RSpec durations are
+      # seconds.
+      def next_test_share
+        Native::Budget.dynamic_share_ms(
+          @budget * 1000, budget_used * 1000, @tests_to_process.size, processed_tests_count
+        ) / 1000.0
+      end
+
+      def processed_tests_count
+        @tests_to_process.count { |id| @metrics.key?(id) && !@metrics[id].deadline.nil? }
       end
     end
   end

data/lib/mergify/rspec/formatter.rb

@@ -1,34 +1,38 @@
 # frozen_string_literal: true
 
 require 'rspec/core/formatters/base_formatter'
-require 'opentelemetry-sdk'
+require_relative 'trace'
+require_relative 'configuration'
+
+require 'mergify/rspec/native'
 
 module Mergify
   module RSpec
-    # RSpec formatter that creates OpenTelemetry spans for Mergify Test Insights and
+    # RSpec formatter that records spans for Mergify Test Insights and
     # prints a terminal report. It is purely observational and does not modify
     # test execution.
     # rubocop:disable-next Metrics/ClassLength
     class Formatter < ::RSpec::Core::Formatters::BaseFormatter
-      ::RSpec::Core::Formatters.register self,
-                                         :start,
-                                         :example_started,
-                                         :example_finished,
-                                         :example_pending,
-                                         :stop
+      # What it listens to once attached, `start` excepted: it is attached after
+      # that notification, and handed it directly.
+      NOTIFICATIONS = %i[example_started example_finished example_pending stop].freeze
+
+      # @mergifyio/vitest's sentence, for the same withheld verdict.
+      WITHHELD_VERDICT = TestSelection.wrap(
+        "Mergify wasn't sent this run's results: it failed outside any example. If this merge-queue " \
+        'batch is retried, this job will run its full test suite.'
+      )
+
+      ::RSpec::Core::Formatters.register self, :start, *NOTIFICATIONS
 
-      # rubocop:disable-next Metrics/MethodLength
       def start(notification)
         super
 
         @ci_insights = Mergify::RSpec.ci_insights
-        return unless @ci_insights&.tracer
-
-        extract_distributed_trace_context
+        return unless @ci_insights&.recorder
 
-        @session_span = @ci_insights.tracer.start_span(
+        @session_span = @ci_insights.recorder.start_span(
           'rspec session start',
-          with_parent: @parent_context,
           attributes: { 'test.scope' => 'session' }
         )
         @has_error = false
@@ -36,21 +40,20 @@ module Mergify
       end
 
       def example_started(notification)
-        return unless @ci_insights&.tracer && @session_span
+        return unless @ci_insights&.recorder && @session_span
 
         example = notification.example
-        parent_context = OpenTelemetry::Trace.context_with_span(@session_span)
         quarantined = @ci_insights.mark_test_as_quarantined_if_needed(example.id)
 
-        span = @ci_insights.tracer.start_span(
+        span = @ci_insights.recorder.start_span(
           example.id,
-          with_parent: parent_context,
+          parent: @session_span,
           attributes: build_example_attributes(example, quarantined)
         )
         @example_spans[example.id] = span
       end
 
-      # rubocop:disable-next Metrics/MethodLength
+      # rubocop:disable-next Metrics/MethodLength,Metrics/AbcSize
       def example_finished(notification)
         return unless @example_spans
 
@@ -59,6 +62,7 @@ module Mergify
         return unless span
 
         result = example.execution_result
+        @ci_insights.session_verdict.record(example.id, verdict_status(example), result.run_time)
         status = result.status.to_s
         span.set_attribute('test.case.result.status', status)
         set_flaky_attributes(span, example)
@@ -67,10 +71,10 @@ module Mergify
           set_error_attributes(span, result.exception)
           @has_error = true
         else
-          span.status = OpenTelemetry::Trace::Status.ok
+          span.ok!
         end
 
-        span.finish
+        @ci_insights.recorder.record(span)
       end
 
       def example_pending(notification)
@@ -81,23 +85,48 @@ module Mergify
         return unless span
 
         span.set_attribute('test.case.result.status', 'skipped')
-        span.finish
+        @ci_insights.session_verdict.record(example.id, verdict_status(example), example.execution_result.run_time)
+        @ci_insights.recorder.record(span)
       end
 
       def stop(_notification)
         finish_session_span
+        # The verdict first, on purpose: it is what the next merge-queue rerun
+        # of this job is answered from, and it must never wait behind the
+        # trace upload's timeout and retries.
+        send_session_verdict
         print_report
         flush_and_shutdown
       end
 
       private
 
-      def extract_distributed_trace_context
-        traceparent = ENV.fetch('MERGIFY_TRACEPARENT', nil)
-        @parent_context = if traceparent
-                            propagator = OpenTelemetry::Trace::Propagation::TraceContext::TextMapPropagator.new
-                            propagator.extract({ 'traceparent' => traceparent })
-                          end
+      # The status RSpec reported, which is the one that decided the exit
+      # code. A pending example is a skip, unless it is a failure the
+      # quarantine absorbed.
+      def verdict_status(example)
+        result = example.execution_result
+        case result.status
+        when :passed then 'passed'
+        when :failed then 'failed'
+        else
+          quarantined = example.metadata[:mergify_quarantined] &&
+                        result.pending_message == Configuration::QUARANTINE_MESSAGE
+          quarantined ? 'quarantined_failed' : 'skipped'
+        end
+      end
+
+      def send_session_verdict
+        return unless @ci_insights&.recorder
+
+        @ci_insights.send_session_verdict(failed_outside_examples: failed_outside_examples?)
+      end
+
+      # RSpec flags a failure no example carries -- a failing `after(:context)`
+      # or suite hook. A load error flags it too, but stops the run before the
+      # formatter is ever attached.
+      def failed_outside_examples?
+        ::RSpec.world.non_example_failure ? true : false
       end
 
       def build_example_attributes(example, quarantined)
@@ -133,18 +162,18 @@ module Mergify
         span.set_attribute('exception.type', exception.class.to_s)
         span.set_attribute('exception.message', exception.message)
         span.set_attribute('exception.stacktrace', exception.backtrace&.join("\n") || '')
-        span.status = OpenTelemetry::Trace::Status.error(exception.message)
+        span.error!(exception.message)
       end
 
       def finish_session_span
         return unless @session_span
 
-        @session_span.status = if @has_error
-                                 OpenTelemetry::Trace::Status.error('One or more tests failed')
-                               else
-                                 OpenTelemetry::Trace::Status.ok
-                               end
-        @session_span.finish
+        if @has_error
+          @session_span.error!('One or more tests failed')
+        else
+          @session_span.ok!
+        end
+        @ci_insights.recorder.record(@session_span)
       end
 
       # rubocop:disable-next Metrics/MethodLength
@@ -160,6 +189,7 @@ module Mergify
         print_configuration_warnings
         print_flaky_report
         print_quarantine_report
+        print_test_selection_report
         output.puts "MERGIFY_TEST_RUN_ID=#{@ci_insights.test_run_id}"
         output.puts '------------------'
       end
@@ -167,12 +197,21 @@ module Mergify
       def print_configuration_warnings
         output.puts 'WARNING: MERGIFY_TOKEN is not set. Traces will not be sent to Mergify.' unless @ci_insights.token
 
+        return print_native_warning unless Mergify::RSpec::Native.available?
         return if @ci_insights.repo_name
 
         output.puts 'WARNING: Could not detect repository name. ' \
                     'Please set GITHUB_REPOSITORY or configure a git remote.'
       end
 
+      # The extension is what detects CI, so when it did not load there is no
+      # repository name either, and blaming that would send people hunting for a
+      # git remote that is fine. Say what actually happened instead.
+      def print_native_warning
+        output.puts 'WARNING: the Mergify native extension could not be loaded, so this run reports nothing: ' \
+                    "#{Mergify::RSpec::Native.load_error&.message}"
+      end
+
       def print_flaky_report
         return unless @ci_insights.flaky_detector.respond_to?(:make_report)
 
@@ -187,20 +226,24 @@ module Mergify
         output.puts report if report
       end
 
-      def flush_and_shutdown # rubocop:disable Metrics/MethodLength
-        return unless @ci_insights&.tracer_provider
+      # One block whatever happened, once the job asked for a selection.
+      def print_test_selection_report
+        selection = @ci_insights.test_selection
+        return unless selection
 
-        begin
-          @ci_insights.tracer_provider.force_flush
-        rescue StandardError => e
-          print_export_error(e)
-        end
+        output.puts selection.report
+        output.puts WITHHELD_VERDICT if @ci_insights.session_verdict_withheld
+        verdict_report = @ci_insights.session_verdict_result.report
+        output.puts verdict_report if verdict_report
+      end
 
-        begin
-          @ci_insights.tracer_provider.shutdown
-        rescue StandardError => e
-          output.puts "Error while shutting down the tracer: #{e.message}"
-        end
+      # One upload, at the end. There is nothing to shut down any more: the
+      # recorder holds spans in memory and the client owns the connection.
+      def flush_and_shutdown
+        return unless @ci_insights&.recorder
+
+        error = @ci_insights.flush
+        print_export_error(StandardError.new(error)) if error
       end
 
       def print_export_error(error)

data/lib/mergify/rspec/native.rb

@@ -27,21 +27,42 @@ module Mergify
         def available?
           load_error.nil?
         end
+
+        # Which of the two failed requires actually explains the absence.
+        #
+        # A precompiled gem ships lib/mergify/rspec/<ruby>/mergify_ci.<dlext>,
+        # so when one is packed for this Ruby that require is the real attempt:
+        # it fails with something like "version `GLIBC_2.29' not found", and the
+        # fallback that follows only ever adds "cannot load such file", which
+        # sends the reader looking for the wrong thing. With no extension for
+        # this Ruby -- the source gem, or a platform we publish no gem for --
+        # it is the other way round.
+        # Require a file next to this one, returning the LoadError instead of
+        # raising it. Two attempts read better as values than as nested rescues.
+        def attempt_require(path)
+          require_relative path
+          nil
+        rescue LoadError => e
+          e
+        end
+
+        def load_failure_reason(versioned, fallback)
+          packed = Dir.glob(File.join(__dir__, RUBY_VERSION.to_f.to_s, 'mergify_ci.*')).any?
+          packed ? versioned : fallback
+        end
       end
     end
   end
 end
 
-begin
-  # Precompiled gems ship lib/mergify/rspec/<ruby>/mergify_ci.<dlext>.
-  require_relative "#{RUBY_VERSION.to_f}/mergify_ci"
-rescue LoadError
-  begin
-    # Source gem, and any local `rake compile`.
-    require_relative 'mergify_ci'
-  rescue LoadError => e
-    Mergify::RSpec::Native.load_error = e
-  end
+# Precompiled gems ship lib/mergify/rspec/<ruby>/mergify_ci.<dlext>; the source
+# gem and any local `rake compile` put one beside this file instead.
+versioned_error = Mergify::RSpec::Native.attempt_require("#{RUBY_VERSION.to_f}/mergify_ci")
+fallback_error = versioned_error && Mergify::RSpec::Native.attempt_require('mergify_ci')
+
+if fallback_error
+  Mergify::RSpec::Native.load_error =
+    Mergify::RSpec::Native.load_failure_reason(versioned_error, fallback_error)
 end
 
 unless Mergify::RSpec::Native.available?

data/lib/mergify/rspec/quarantine.rb

@@ -48,13 +48,19 @@ module Mergify
         lines << "  Quarantined tests run (#{used.size}):"
         used.each { |t| lines << "    - #{t}" }
         lines << ''
-        lines << "  Unused quarantined tests (#{unused.size}):"
+        lines << "  #{unused_label} (#{unused.size}):"
         unused.each { |t| lines << "    - #{t}" }
         lines.join("\n")
       end
 
       private
 
+      # A parallel worker runs a share of the suite, so a quarantined test it
+      # did not run was most likely run by another worker, not left unused.
+      def unused_label
+        Utils.parallel_worker? ? 'Quarantined tests not run by this worker' : 'Unused quarantined tests'
+      end
+
       # A nil list means the repository has no quarantine subscription, which is
       # not an error: the session simply quarantines nothing. Anything that went
       # genuinely wrong is recorded and the suite carries on -- this plugin has