minitest-mergify 2026.10.8 → 2026.10.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1f8329ced091f90450e17fd2609fb2f0c4b2473a4c9b4a3dcb2894976ca7cca1
-  data.tar.gz: ca3816579117094718c11e849cac1674eff03803feb7302c63533cd2710acc31
+  metadata.gz: 0ed7de1c1d2ed7a6d5de874d3b9afbd42144b62f3db77e395943b98e16f1a6ce
+  data.tar.gz: 71a773ec460d13ae629703b569f6de02e46787bf0d78b17c6c85a149e6b55756
 SHA512:
-  metadata.gz: d7a4608e8303cfe68b9b9a27fac19ec798ffc0deecd61987823903fba281f6d741a97c647e1ca936b05731282e7235b3c6855f78346e43d35d5332577e79a146
-  data.tar.gz: ef2e7eabb0d85e518a066e94fabebf9a212afe436a40e8018c50d013f782e5747fafcb86a4b90f923960bc43f4c012a689fdcb251c740c58ef60fe448571c8be
+  metadata.gz: b1be6af5d90daee9af0f99b3e603d43c9c464907c4b606c68b1a4b23462cd4ae897f22a384a16f5b1c4c4a5bb9fb0ce8ebcf6ea6837682eed6e087643424066d
+  data.tar.gz: 8a93ea8e43e3a63ccb9ed21754e10fc94280618e656f8b810de43dd8350d01148eddea5d241fee269884fda53126f73cb67da7304ba89caf76e86f3ec9021325

data/README.md

@@ -8,6 +8,7 @@ Minitest plugin for [Mergify Test Engine](https://docs.mergify.com/test-engine/)
 - **Test quarantine** — Quarantines failing tests so they don't block CI
 - **Test selection** — Runs first the tests that failed in a merge-queue bisection step, and stops once one fails again
 - **Flaky test detection** — Reruns new tests to catch flaky ones before they merge
+- **Test retry** — On the default branch, runs a failing test again, within a time budget Mergify sets
 
 ## Installation
 
@@ -34,7 +35,7 @@ It supports Minitest 5.19 and later, on Ruby 3.1 and later, and Minitest 6 on
 Ruby 3.2 and later: tests in classes and in `describe` blocks, run in one
 process, in Minitest's threads (`parallelize_me!`) or in Rails' parallel
 workers (`parallelize`). It runs on `mergify-ci-core`, which Bundler installs
-with it and which ships precompiled for Linux (glibc 2.30 or newer, and musl),
+with it and which ships precompiled for Linux (glibc 2.28 or newer, and musl),
 macOS and Windows.
 
 ## Configuration
@@ -55,6 +56,7 @@ environment variable). To enable outside CI, set `MERGIFY_CI_ENABLE=true`.
 | `MERGIFY_TRACEPARENT` | W3C distributed trace context | — |
 | `MERGIFY_TEST_JOB_NAME` | Mergify test job name | — |
 | `MERGIFY_FAIL_FIRST_ENABLE` | Set to `false` to never run first what a merge-queue bisection step of this job failed before (see below) | `true` |
+| `MERGIFY_TEST_RETRY_ENABLE` | Set to `false` to have this job retry no failing test, whatever the repository sets | `true` |
 
 ### Quarantine
 
@@ -105,6 +107,20 @@ without failing the job. The reruns go through Minitest itself, so they run
 where the test ran: in one process, in Minitest's threads, or in Rails'
 parallel workers.
 
+### Test retry
+
+On a push to the repository's default branch, when a test fails, the plugin
+runs it again, up to the number of retries the repository sets, within a time
+budget for the whole run. If a retry passes, so does the test: Minitest's own
+reporters see the retry that passed instead of the failure, and Mergify still
+learns the test failed first. A quarantined test, and one Mergify classifies
+as broken, are not retried; pull requests, merge-queue runs and other branches
+never are. The retries go through Minitest itself, as flaky detection's reruns
+do.
+
+A job that sets `MERGIFY_TEST_RETRY_ENABLE=false` retries nothing, whatever
+the repository sets.
+
 ### Test names
 
 A test in a class is named as Minitest names it, `UserTest#test_valid`. A test

data/THIRD_PARTY_LICENSES

@@ -8,8 +8,8 @@ The source code of each component is available from the repository listed
 next to it, as the Mozilla Public License 2.0 requires for the components
 under it.
 
-Apache License 2.0 (230)
-MIT License (73)
+Apache License 2.0 (229)
+MIT License (74)
 Unicode License v3 (19)
 ISC License (5)
 BSD 3-Clause "New" or "Revised" License (4)
@@ -23,7 +23,7 @@ Apache License 2.0 (Apache-2.0)
 
 Used by:
   - cmov 0.5.4 (https://github.com/RustCrypto/utils)
-  - ctutils 0.4.3 (https://github.com/RustCrypto/utils)
+  - ctutils 0.4.6 (https://github.com/RustCrypto/utils)
   - encode_unicode 1.0.0 (https://github.com/tormol/encode_unicode)
   - encoding_rs 0.8.42 (https://github.com/hsivonen/encoding_rs)
   - multiversion_no_op 1.0.0 (https://github.com/hsivonen/multiversion_no_op)
@@ -474,11 +474,7 @@ Used by:
   - windows-link 0.2.1 (https://github.com/microsoft/windows-rs)
   - windows-result 0.4.1 (https://github.com/microsoft/windows-rs)
   - windows-strings 0.5.1 (https://github.com/microsoft/windows-rs)
-  - windows-sys 0.52.0 (https://github.com/microsoft/windows-rs)
   - windows-sys 0.61.2 (https://github.com/microsoft/windows-rs)
-  - windows-targets 0.52.6 (https://github.com/microsoft/windows-rs)
-  - windows_x86_64_gnu 0.52.6 (https://github.com/microsoft/windows-rs)
-  - windows_x86_64_msvc 0.52.6 (https://github.com/microsoft/windows-rs)
 
                                  Apache License
                            Version 2.0, January 2004
@@ -2571,14 +2567,14 @@ limitations under the License.
 Apache License 2.0 (Apache-2.0)
 
 Used by:
-  - futures-channel 0.3.33 (https://github.com/rust-lang/futures-rs)
-  - futures-core 0.3.33 (https://github.com/rust-lang/futures-rs)
+  - futures-channel 0.3.34 (https://github.com/rust-lang/futures-rs)
+  - futures-core 0.3.34 (https://github.com/rust-lang/futures-rs)
   - futures-executor 0.3.33 (https://github.com/rust-lang/futures-rs)
-  - futures-io 0.3.33 (https://github.com/rust-lang/futures-rs)
-  - futures-macro 0.3.33 (https://github.com/rust-lang/futures-rs)
-  - futures-sink 0.3.33 (https://github.com/rust-lang/futures-rs)
-  - futures-task 0.3.33 (https://github.com/rust-lang/futures-rs)
-  - futures-util 0.3.33 (https://github.com/rust-lang/futures-rs)
+  - futures-io 0.3.34 (https://github.com/rust-lang/futures-rs)
+  - futures-macro 0.3.34 (https://github.com/rust-lang/futures-rs)
+  - futures-sink 0.3.34 (https://github.com/rust-lang/futures-rs)
+  - futures-task 0.3.34 (https://github.com/rust-lang/futures-rs)
+  - futures-util 0.3.34 (https://github.com/rust-lang/futures-rs)
   - futures 0.3.33 (https://github.com/rust-lang/futures-rs)
 
                               Apache License
@@ -4882,6 +4878,7 @@ Apache License 2.0 (Apache-2.0)
 Used by:
   - ahash 0.8.12 (https://github.com/tkaitchuck/ahash)
   - async-channel 2.5.0 (https://github.com/smol-rs/async-channel)
+  - async-compression 0.4.51 (https://github.com/Nullus157/async-compression)
   - async-executor 1.14.0 (https://github.com/smol-rs/async-executor)
   - async-io 2.6.0 (https://github.com/smol-rs/async-io)
   - async-lock 3.4.2 (https://github.com/smol-rs/async-lock)
@@ -4894,6 +4891,8 @@ Used by:
   - bitflags 2.13.1 (https://github.com/bitflags/bitflags)
   - blocking 1.7.0 (https://github.com/smol-rs/blocking)
   - cfg-if 1.0.4 (https://github.com/rust-lang/cfg-if)
+  - compression-codecs 0.4.46 (https://github.com/Nullus157/async-compression)
+  - compression-core 0.4.34 (https://github.com/Nullus157/async-compression)
   - concurrent-queue 2.5.0 (https://github.com/smol-rs/concurrent-queue)
   - core-foundation-sys 0.8.7 (https://github.com/servo/core-foundation-rs)
   - core-foundation 0.10.1 (https://github.com/servo/core-foundation-rs)
@@ -4951,7 +4950,7 @@ Used by:
   - secret-service 5.2.0 (https://github.com/hwchen/secret-service-rs.git)
   - security-framework-sys 2.17.0 (https://github.com/kornelski/rust-security-framework)
   - security-framework 3.7.0 (https://github.com/kornelski/rust-security-framework)
-  - self-replace 1.5.0 (https://github.com/mitsuhiko/self-replace)
+  - self-replace 1.5.1 (https://github.com/mitsuhiko/self-replace)
   - signal-hook-registry 1.4.8 (https://github.com/vorner/signal-hook)
   - smallvec 1.15.2 (https://github.com/servo/rust-smallvec)
   - socket2 0.6.5 (https://github.com/rust-lang/socket2)
@@ -8791,7 +8790,7 @@ THIS SOFTWARE.
 ISC License (ISC)
 
 Used by:
-  - rustls-webpki 0.103.15 (https://github.com/rustls/webpki)
+  - rustls-webpki 0.103.16 (https://github.com/rustls/webpki)
 
 Except as otherwise noted, this project is licensed under the following
 (ISC-style) terms:
@@ -9826,10 +9825,10 @@ SOFTWARE.
 MIT License (MIT)
 
 Used by:
-  - jsonschema-regex 0.60.0 (https://github.com/Stranger6667/jsonschema)
-  - jsonschema-value 0.60.0 (https://github.com/Stranger6667/jsonschema)
-  - jsonschema 0.60.0 (https://github.com/Stranger6667/jsonschema)
-  - referencing 0.60.0 (https://github.com/Stranger6667/jsonschema)
+  - jsonschema-regex 0.60.2 (https://github.com/Stranger6667/jsonschema)
+  - jsonschema-value 0.60.2 (https://github.com/Stranger6667/jsonschema)
+  - jsonschema 0.60.2 (https://github.com/Stranger6667/jsonschema)
+  - referencing 0.60.2 (https://github.com/Stranger6667/jsonschema)
 
 MIT License
 
@@ -10083,6 +10082,7 @@ USE OR OTHER DEALINGS IN THE SOFTWARE.
 MIT License (MIT)
 
 Used by:
+  - tokio-util 0.7.19 (https://github.com/tokio-rs/tokio)
   - tokio 1.54.1 (https://github.com/tokio-rs/tokio)
 
 MIT License

data/lib/mergify/minitest/plugin.rb

@@ -7,6 +7,7 @@ require_relative 'test_run'
 require_relative 'names'
 require_relative 'recorder'
 require_relative 'reruns'
+require_relative 'retries'
 require_relative 'selection'
 
 module Mergify
@@ -60,14 +61,21 @@ module Mergify
           start(reporter, test_run, options)
         end
 
-        # The run's suites, as the selection runs them, then flaky detection's
-        # reruns -- not after a stop Fail First made, whose whole point is to
-        # end the job sooner.
+        # The run's suites, as the selection runs them, once the session
+        # prepared its reruns; then test retry's retries and flaky
+        # detection's reruns -- not after a stop Fail First made, whose whole
+        # point is to end the job sooner -- and last the failures test retry
+        # held back for flaky detection's reruns.
         def run_suites(reporter, &)
           return yield unless @selection
 
+          @reruns.prepare
           @selection.run(@recorder, &)
-          @reruns.run(reporter, @recorder) unless @recorder.stopping?
+          unless @recorder.stopping?
+            @retries.settle(@recorder, @selection.names_to_run)
+            @reruns.run(reporter, @recorder)
+          end
+          @recorder.release_held(reporter)
         end
 
         private
@@ -79,7 +87,8 @@ module Mergify
           @selection = nil
           @selection = select(test_run, names, options)
           @reruns = @selection && Reruns.new(test_run, @selection)
-          @recorder = Recorder.new(test_run, names, options[:io] || $stdout, @selection, @reruns)
+          @retries = @selection && Retries.new(test_run, @selection, @reruns)
+          @recorder = Recorder.new(test_run, names, options[:io] || $stdout, @selection, @reruns, @retries)
           @recorder.attach(reporter)
           install
         end

data/lib/mergify/minitest/recorder.rb

@@ -7,8 +7,8 @@ require_relative 'results'
 module Mergify
   module Minitest
     # Hands each finished test to the session, for the run's trace, its
-    # verdict, the quarantine, Fail First and flaky detection, and prints what
-    # the session says once the run is over.
+    # verdict, the quarantine, Fail First, flaky detection and test retry, and
+    # prints what the session says once the run is over.
     #
     # It wraps the reporter Minitest sends every result through, rather than
     # joining the reporters inside it: a plugin can replace those, and
@@ -28,16 +28,23 @@ module Mergify
       attr_reader :first_attempts
 
       # `selection` is the run's, when it asked Test Selection; nil when it
-      # does not report. `reruns`, flaky detection's, takes the results of the
-      # tests it reruns.
-      def initialize(test_run, names, io, selection, reruns)
+      # does not report. `reruns`, the session's, takes the results of the
+      # tests flaky detection reruns, and `retries` those of the tests test
+      # retry retries.
+      # rubocop:disable-next Metrics/MethodLength,Metrics/ParameterLists
+      def initialize(test_run, names, io, selection, reruns, retries)
         @test_run = test_run
         @names = names
         @io = io
         @selection = selection
         @reruns = reruns
+        @retries = retries
         @fail_first = selection && test_run.fail_first
         @first_attempts = {}
+        # The results Minitest's own reporters get as they are: the failures
+        # test retry held back for flaky detection's reruns, once they are
+        # over.
+        @released = {}.compare_by_identity
         @lock = Mutex.new
         @changed = ConditionVariable.new
         @stopping = false
@@ -48,30 +55,35 @@ module Mergify
         reporter.singleton_class.prepend(hooks)
       end
 
-      # Before Minitest's own reporters count the result: a failure the
+      # What Minitest's own reporters get of `result`, which `reporter`
+      # records, before they count it; nil for nothing. A failure the
       # quarantine absorbs reaches them as a skip, so it fails nothing, and
-      # Mergify still sees it fail.
-      def record(result)
-        return unless @test_run.reports?
+      # Mergify still sees it fail. A rerun of flaky detection's never does. A
+      # failure test retry answers for is held back until it answered, then
+      # reaches them as the retry that passed, or as itself.
+      def pass_on(result, reporter)
+        return result if @released.delete(result) || !@test_run.reports?
+        return if rerun_taken?(result)
+        return retry_taken(result, reporter) if @retries&.retrying?(result.klass, result.name)
 
-        named = named(result)
-        status = Results.status_of(result)
-        absorbed = trace(result, named, status)
-        conclude(named.name, status, absorbed, result.time)
+        record(result, reporter)
       end
 
-      # Whether `result` is a rerun's, which flaky detection takes as an
-      # attempt and Minitest's own reporters never see.
-      def rerun_taken?(result)
-        return false unless @reruns&.rerun?(result.klass, result.name)
-
-        @reruns.take(result, named(result).name)
+      # Whether Minitest is about to report a rerun or a retry of `method` of
+      # `klass` (a class, or what Rails' workers report its name as).
+      def rerun?(klass, method)
+        klass = klass.respond_to?(:name) ? klass.name : klass.to_s
+        @reruns&.rerun?(klass, method) || @retries&.retrying?(klass, method) || false
       end
 
-      # Whether Minitest is about to report a rerun of `method` of `klass` (a
-      # class, or what Rails' workers report its name as).
-      def rerun?(klass, method)
-        @reruns&.rerun?(klass.respond_to?(:name) ? klass.name : klass.to_s, method) || false
+      # Hand Minitest's own reporters, through `reporter`, the failures test
+      # retry held back for flaky detection's reruns, once they are over.
+      def release_held(reporter)
+        @retries&.answered&.each do |name, result|
+          conclude(name, Results.status_of(result), false, result.time)
+          @released[result] = true
+          reporter.record(result)
+        end
       end
 
       # Whether flaky detection found a new test flaky, in reruns Minitest's
@@ -106,6 +118,43 @@ module Mergify
 
       private
 
+      # A test's first result: its span, the quarantine, the session's
+      # reruns, then its final status, unless test retry holds its failure
+      # back. Answers the result Minitest's own reporters get, nil while held
+      # back.
+      def record(result, reporter)
+        named = named(result)
+        name = named.name
+        status = Results.status_of(result)
+        absorbed = trace(result, named, status)
+        @reruns&.first_attempt(name, status, result.time * 1000)
+        held = !absorbed && @retries&.hold?(result, name, reporter)
+        conclude(name, status, absorbed, result.time) unless held
+        recorded(name, status, result.time)
+        result unless held
+      end
+
+      # Whether `result` is a rerun's, which flaky detection takes as an
+      # attempt, and test retry too where it holds the test's failure back.
+      def rerun_taken?(result)
+        return false unless @reruns&.rerun?(result.klass, result.name)
+
+        name = named(result).name
+        return false unless @reruns.take(result, name)
+
+        @retries&.rerun_ended(name, result)
+        true
+      end
+
+      # A retry's result, which test retry takes: once it answered, the
+      # result Minitest's own reporters get, whose status is the test's.
+      def retry_taken(result, reporter)
+        name = named(result).name
+        released = @retries.take(result, name, reporter)
+        conclude(name, Results.status_of(released), false, released.time) if released
+        released
+      end
+
       # The test's span, as the quarantine accounts for it, and the failure
       # it absorbs: whether it did.
       def trace(result, named, status)
@@ -119,16 +168,20 @@ module Mergify
         @names.of(result.klass, result.name, result.source_location.first)
       end
 
-      # The test's first attempt, as it ended, for flaky detection, and its
-      # final status, for the verdict and Fail First: a failure the quarantine
-      # absorbed is none.
+      # The test's final status, for the verdict and Fail First: a failure
+      # the quarantine absorbed is none.
       def conclude(name, status, absorbed, time)
         final = absorbed ? 'quarantined_failed' : status
         @test_run.record_test(name, final, time)
         stop = @fail_first&.unit_done(name, final == 'failed')
+        @lock.synchronize { @stopping ||= stop }
+      end
+
+      # The test's first attempt was recorded, after its final status unless
+      # test retry held it back.
+      def recorded(name, status, time)
         @lock.synchronize do
           @first_attempts[name] ||= [status, time * 1000]
-          @stopping ||= stop
           @changed.broadcast
         end
       end
@@ -152,10 +205,8 @@ module Mergify
           end
 
           define_method(:record) do |result|
-            next if recorder.rerun_taken?(result)
-
-            recorder.record(result)
-            super(result)
+            passed_on = recorder.pass_on(result, self)
+            super(passed_on) if passed_on
           end
 
           define_method(:passed?) do

data/lib/mergify/minitest/reruns.rb

@@ -5,22 +5,45 @@ require_relative 'results'
 
 module Mergify
   module Minitest
-    # Flaky detection, once the run's tests are over: the session plans how
-    # many times to rerun the tests it targets, from their first attempts, and
-    # each rerun goes through Minitest's own dispatch, so it runs where the
-    # test ran -- inline, in Minitest's threads, or in Rails' workers -- and
-    # its result comes back to the reporter Minitest records results through.
-    # There, each is an attempt for the session, which Minitest's own
-    # reporters never see.
+    # The session's reruns for the run, and flaky detection's, once the run's
+    # tests are over: the session plans how many times to rerun the tests it
+    # targets, from their first attempts, and each rerun goes through
+    # Minitest's own dispatch, so it runs where the test ran -- inline, in
+    # Minitest's threads, or in Rails' workers -- and its result comes back to
+    # the reporter Minitest records results through. There, each is an
+    # attempt for the session, which Minitest's own reporters never see.
     class Reruns
+      # The session's reruns, once prepared: nil before, and when neither
+      # flaky detection nor test retry runs.
+      attr_reader :prepared
+
       def initialize(test_run, selection)
         @test_run = test_run
         @selection = selection
+        @prepared = nil
         @pending = Hash.new(0)
         @lock = Mutex.new
         @changed = ConditionVariable.new
       end
 
+      # Prepare the session's reruns before any test runs, for every test the
+      # run is to run, where test retry retries: it answers each failure as
+      # it comes. Flaky detection alone waits for the run's tests to be over.
+      def prepare
+        prepare_for(@selection.tests.map(&:name)) if @test_run.test_retry_runs?
+      end
+
+      # The first attempt at the test named `name` ended with `outcome` after
+      # `duration_ms`: the session takes it, once the reruns are prepared,
+      # where flaky detection targets the test or test retry answers for it,
+      # as it passed or failed.
+      def first_attempt(name, outcome, duration_ms)
+        return unless @prepared && %w[passed failed].include?(outcome)
+        return unless @prepared.tracks?(name) || @prepared.retry_answers_for?(name)
+
+        @test_run.record_attempt(name, outcome, duration_ms)
+      end
+
       # Rerun what flaky detection targets, once `recorder` recorded every test
       # the run was to run: a run in Minitest's threads or Rails' workers
       # hands its results back after its suites were handed over.
@@ -28,8 +51,8 @@ module Mergify
         return unless @test_run.flaky_detection_runs?
 
         recorder.wait_for(@selection.names_to_run)
-        reruns = prepare(recorder.first_attempts)
-        plan = reruns&.shared_repeats
+        prepare_after(recorder.first_attempts) unless @prepared
+        plan = @prepared&.shared_repeats
         rerun(plan, reporter) if plan
       end
 
@@ -55,18 +78,18 @@ module Mergify
 
       private
 
-      # The session's reruns for every test the run ran, each known by its
-      # former name too, with the first attempt of each test flaky detection
-      # targets, as it passed or failed.
-      def prepare(first_attempts)
+      # The session's reruns for the tests named `names`, each known by its
+      # former name too.
+      def prepare_for(names)
         former_names = @selection.tests.to_h { |test| [test.name, ["#{test.klass.name}.#{test.method_name}"]] }
-        reruns = @test_run.prepare_reruns(first_attempts.keys, former_names)
-        first_attempts.each do |name, (outcome, duration_ms)|
-          next unless reruns&.tracks?(name) && %w[passed failed].include?(outcome)
+        @prepared = @test_run.prepare_reruns(names, former_names)
+      end
 
-          @test_run.record_attempt(name, outcome, duration_ms)
-        end
-        reruns
+      # The session's reruns once the run's tests are over, for every test it
+      # ran, with the first attempt of each.
+      def prepare_after(first_attempts)
+        prepare_for(first_attempts.keys)
+        first_attempts.each { |name, (outcome, duration_ms)| first_attempt(name, outcome, duration_ms) }
       end
 
       # Each test of `plan` again, as many times as it says, round after
@@ -74,7 +97,7 @@ module Mergify
       def rerun(plan, reporter)
         tests = @selection.tests.select { |test| plan['tests'].include?(test.name) }
         expect(tests, plan['repeats'])
-        plan['repeats'].times { tests.each { |test| dispatch(test, reporter) } }
+        plan['repeats'].times { tests.each { |test| test.dispatch(reporter) } }
         @lock.synchronize { @changed.wait(@lock) until @pending.values.all?(&:zero?) }
       end
 
@@ -82,16 +105,6 @@ module Mergify
       def expect(tests, repeats)
         @lock.synchronize { tests.each { |test| @pending[[test.klass.name, test.method_name]] += repeats } }
       end
-
-      # As Minitest runs a test of a class: inline and reported, or handed to
-      # its parallel executor, which reports it once it ran.
-      def dispatch(test, reporter)
-        if ::Minitest::Runnable.respond_to?(:run_suite)
-          test.klass.run(test.klass, test.method_name, reporter)
-        else
-          test.klass.run_one_method(test.klass, test.method_name, reporter)
-        end
-      end
     end
   end
 end

data/lib/mergify/minitest/retries.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+require 'minitest'
+require 'set'
+require_relative 'results'
+
+module Mergify
+  module Minitest
+    # Test retry: a test whose first attempt failed runs again, through
+    # Minitest's own dispatch, as long as the session grants it one more
+    # attempt, so it runs where it ran -- inline, in Minitest's threads, or in
+    # Rails' workers -- and each result comes back to the reporter Minitest
+    # records results through, in the main process, which asks the session
+    # for the next. Its failure is held back from Minitest's own reporters
+    # until retry answered: a retry that passed reaches them in its place,
+    # and the failure itself otherwise.
+    #
+    # Which failures retry answers for, how many retries a test gets and
+    # within which budget are the session's. A test flaky detection reruns is
+    # retry's to answer for with those reruns, once the suite is over: its
+    # failure is held back until then.
+    class Retries
+      def initialize(test_run, selection, reruns)
+        @test_run = test_run
+        @tests = selection.tests.to_h { |test| [test.name, test] }
+        @reruns = reruns
+        # The failures held back, by name, until retry answered.
+        @held = {}
+        # The tests retried, by class name and method, until retry answered.
+        @retrying = Set.new
+        # A passing rerun of flaky detection's, by name, for a failure held
+        # back until its reruns are over.
+        @passed = {}
+        @lock = Mutex.new
+        @changed = ConditionVariable.new
+      end
+
+      # The first attempt at the test named `name` ended with `result`,
+      # which the session took: whether retry holds it back, a failure it
+      # answers for. A test the session grants a retry runs again; one flaky
+      # detection reruns waits for its reruns.
+      def hold?(result, name, reporter)
+        prepared = @reruns.prepared
+        return false unless Results.status_of(result) == 'failed' && prepared&.retry_answers_for?(name)
+
+        if prepared.grant_retry(name, result.time * 1000)
+          retry_test(result, name, reporter)
+        elsif prepared.tracks?(name)
+          @lock.synchronize { @held[name] = result }
+        else
+          return false
+        end
+        true
+      end
+
+      # Whether Minitest is about to report a retry of `method` of the class
+      # named `klass`, which the reporter keeps from Minitest's own.
+      def retrying?(klass, method)
+        @lock.synchronize { @retrying.include?([klass, method]) }
+      end
+
+      # The result of a retry of the test named `name`, as an attempt: the
+      # result Minitest's own reporters get once retry answered, the one that
+      # passed or the failure held back; nil while the test runs once more.
+      def take(result, name, reporter)
+        status = Results.status_of(result)
+        duration_ms = result.time * 1000
+        @test_run.record_attempt(name, status, duration_ms)
+        return answer(result, name) unless status == 'failed' && @reruns.prepared.grant_retry(name, duration_ms)
+
+        @tests.fetch(name).dispatch(reporter)
+        nil
+      end
+
+      # A rerun of flaky detection's of the test named `name` ended with
+      # `result`.
+      def rerun_ended(name, result)
+        @lock.synchronize do
+          @passed[name] ||= result if @held.key?(name) && Results.status_of(result) == 'passed'
+        end
+      end
+
+      # Wait, once the run's suites were handed over, until `recorder`
+      # recorded every test named `names`, and every retry they were granted
+      # ended, where test retry answers for a failure of any of them:
+      # Minitest's threads and Rails' workers stop once the suites are over.
+      def settle(recorder, names)
+        prepared = @reruns.prepared
+        return unless prepared && names.any? { |name| prepared.retry_answers_for?(name) }
+
+        recorder.wait_for(names)
+        @lock.synchronize { @changed.wait(@lock) until @retrying.empty? }
+      end
+
+      # The failures held back for flaky detection's reruns, once they are
+      # over, by name: the result Minitest's own reporters get for each, a
+      # rerun that passed where it rescued the test, the failure otherwise.
+      def answered
+        held = @lock.synchronize { @held.dup.tap { @held.clear } }
+        held.to_h do |name, failure|
+          passed = @passed[name]
+          [name, passed && @reruns.prepared.rescued?(name) ? passed : failure]
+        end
+      end
+
+      private
+
+      # Hold back the failure `result` of the test named `name`, and run the
+      # test again.
+      def retry_test(result, name, reporter)
+        @lock.synchronize do
+          @held[name] = result
+          @retrying << [result.klass, result.name]
+        end
+        @tests.fetch(name).dispatch(reporter)
+      end
+
+      # Retry answered the failure of the test named `name`, its last retry
+      # ended with `result`: what Minitest's own reporters get, `result`
+      # where a retry rescued the test, the failure held back otherwise.
+      def answer(result, name)
+        held = @lock.synchronize do
+          @retrying.delete([result.klass, result.name])
+          @changed.broadcast
+          @held.delete(name)
+        end
+        @reruns.prepared.rescued?(name) ? result : held
+      end
+    end
+  end
+end

data/lib/mergify/minitest/selection.rb

@@ -15,7 +15,18 @@ module Mergify
     class Selection
       # A test the run collected: its class, its method, and the name Mergify
       # knows it by.
-      Test = Struct.new(:klass, :method_name, :name)
+      Test = Struct.new(:klass, :method_name, :name) do
+        # Run it again, as Minitest runs a test of a class: inline and
+        # reported, or handed to its parallel executor, which reports it once
+        # it ran.
+        def dispatch(reporter)
+          if ::Minitest::Runnable.respond_to?(:run_suite)
+            klass.run(klass, method_name, reporter)
+          else
+            klass.run_one_method(klass, method_name, reporter)
+          end
+        end
+      end
 
       # Every test the run collected, as Minitest's filters left them.
       attr_reader :tests

data/lib/mergify/minitest/test_run.rb

@@ -19,8 +19,9 @@ module Mergify
         # every result and stops the run.
         fail_first: { unit: 'test', waits_for_all: true, workers_stop_the_run: false },
         # Flaky detection reruns a test after the suite, as many times as
-        # every other one it reruns, and nothing retries a failure.
-        reruns: { plans_repeats: true, retries_failures: false },
+        # every other one it reruns; test retry runs a failed one again as it
+        # fails.
+        reruns: { plans_repeats: true, retries_failures: true },
         framework: { name: 'minitest', version: ::Minitest::VERSION, language: 'ruby' }
       }.freeze
 
@@ -93,23 +94,30 @@ module Mergify
         @session.flaky_detection_runs?
       end
 
+      # Whether test retry retries in this run: the repository has it, and
+      # the run builds its default branch.
+      def test_retry_runs?
+        @session.test_retry_runs?
+      end
+
       # Whether flaky detection found a new test flaky, which fails the run.
       def flaky_detection_fails_the_run?
         @session.flaky_detection_fails_the_run?
       end
 
-      # Prepare flaky detection for the tests the run ran, by name, each also
-      # known by its former names (`former_names`, a list by name), which
-      # Mergify's lists may still hold it under: the run's reruns, or nil
-      # when nothing is to rerun. Which tests it reruns, and how many times, are the
-      # session's.
+      # Prepare flaky detection and test retry for the tests named `names`,
+      # each also known by its former names (`former_names`, a list by name),
+      # which Mergify's lists may still hold it under: the run's reruns, or
+      # nil when neither runs. Which tests each reruns, and how many times,
+      # are the session's. No test opts out of test retry: Minitest has no
+      # annotation of Mergify's.
       def prepare_reruns(names, former_names)
         @session.state_former_names(former_names)
         @session.prepare_reruns(names)
       end
 
       # An attempt at a test, ended with `outcome` (`'passed'` or `'failed'`)
-      # after `duration_ms`: its first one, then each rerun.
+      # after `duration_ms`: its first one, then each rerun or retry.
       def record_attempt(name, outcome, duration_ms)
         @session.record_attempt(name, outcome, duration_ms)
       end

data/lib/mergify/minitest/version.rb

@@ -4,6 +4,6 @@ module Mergify
   module Minitest
     # Placeholder: the release workflow stamps the real version from the git
     # tag at build time, as it does for every client in this repository.
-    VERSION = '2026.10.8'
+    VERSION = '2026.10.10'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: minitest-mergify
 version: !ruby/object:Gem::Version
-  version: 2026.10.8
+  version: 2026.10.10
 platform: ruby
 authors:
 - Mergify
@@ -35,14 +35,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2026.10.8
+        version: 2026.10.10
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 2026.10.8
+        version: 2026.10.10
 description: 'Minitest integration for Mergify Test Engine: the run reported to CI
   Insights, test quarantine, Fail First on merge-queue bisection steps, and flaky
   test detection.'
@@ -62,6 +62,7 @@ files:
 - lib/mergify/minitest/recorder.rb
 - lib/mergify/minitest/reruns.rb
 - lib/mergify/minitest/results.rb
+- lib/mergify/minitest/retries.rb
 - lib/mergify/minitest/selection.rb
 - lib/mergify/minitest/test_run.rb
 - lib/mergify/minitest/version.rb