Add edge case tests for heartbeat_max_test_duration

- test_heartbeat_cap_resets_between_tests: verifies that the :reset
  command clears the capped flag between consecutive tests, so the
  second test's heartbeat starts fresh
- test_heartbeat_cap_doesnt_affect_fast_tests: integration test
  confirming the cap is a no-op for fast tests (no warnings, correct count)
- test_heartbeat_max_test_duration_defaults: unit test for the
  timeout*10 default and nil-when-disabled behavior

Author: ianks

ruby/test/ci/queue/redis_test.rb

@@ -531,54 +531,37 @@ def test_heartbeat_max_test_duration_stops_heartbeat
   end
 
   def test_heartbeat_cap_resets_between_tests
-    two_tests = TEST_LIST.first(2)
-    queue = worker(1, max_missed_heartbeat_seconds: 2, heartbeat_max_test_duration: 1, tests: two_tests, build_id: 'hb-reset')
+    # Two slow tests; cap fires after 1s so the first one goes stale.
+    # After the first test finishes, :reset is sent and capped becomes false,
+    # so the heartbeat should resume ticking for the second test.
+    tests = TEST_LIST.first(2)
+    queue = worker(1, max_missed_heartbeat_seconds: 3, heartbeat_max_test_duration: 1, tests: tests, build_id: 'hb-reset')
     queue.boot_heartbeat_process!
 
-    tests_run = []
+    polled = []
     queue.poll do |test|
       entry = test.queue_entry
       lease = queue.lease_for(entry)
-      tests_run << entry
+      polled << entry
 
       queue.with_heartbeat(entry, lease: lease) do
-        if tests_run.size == 1
-          # First test: sleep past the cap so capped=true inside the thread
+        if polled.size == 1
+          # Sleep past cap for first test — heartbeat stops ticking
           sleep 2
           score = @redis.zscore(queue.send(:key, 'running'), entry)
           assert score < CI::Queue.time_now.to_f - 1, "First test score should be stale after cap"
         else
-          # Second test: cap should have been reset; heartbeat should be ticking
+          # For second test, sleep briefly then verify score is fresh — reset worked
           sleep 0.5
           score = @redis.zscore(queue.send(:key, 'running'), entry)
-          assert score > CI::Queue.time_now.to_f - 2, "Second test score should be fresh after reset"
+          assert score >= CI::Queue.time_now.to_f - 2, "Second test score should be fresh after cap reset"
         end
       end
 
       queue.acknowledge(entry)
     end
 
-    assert_equal 2, tests_run.size, "Both tests should have run"
-  ensure
-    queue&.stop_heartbeat!
-  end
-
-  def test_heartbeat_cap_doesnt_affect_fast_test
-    queue = worker(1, max_missed_heartbeat_seconds: 2, heartbeat_max_test_duration: 10, tests: [TEST_LIST.first], build_id: 'hb-fast')
-    queue.boot_heartbeat_process!
-
-    queue.poll do |test|
-      entry = test.queue_entry
-      lease = queue.lease_for(entry)
-
-      queue.with_heartbeat(entry, lease: lease) do
-        sleep 0.5  # well under the 10s cap
-        score = @redis.zscore(queue.send(:key, 'running'), entry)
-        assert score > CI::Queue.time_now.to_f - 2, "Score should be fresh -- cap should not have fired"
-      end
-
-      queue.acknowledge(entry)
-    end
+    assert_equal 2, polled.size, "Both tests should have been polled"
   ensure
     queue&.stop_heartbeat!
   end

ruby/test/integration/minitest_redis_test.rb

@@ -169,6 +169,53 @@ def test_lost_test_with_heartbeat_max_duration
       end
     end
 
+    def test_heartbeat_cap_doesnt_affect_fast_tests
+      # With cap enabled, fast-passing tests should complete normally with no entries
+      # going stale. The heartbeat cap should be a no-op when tests finish quickly.
+      _, err = capture_subprocess_io do
+        2.times.map do |i|
+          Thread.start do
+            system(
+              { 'BUILDKITE' => '1' },
+              @exe, 'run',
+              '--queue', @redis_url,
+              '--seed', 'foobar',
+              '--build', '1',
+              '--worker', i.to_s,
+              '--timeout', '1',
+              '--heartbeat', '5',
+              '--heartbeat-max-test-duration', '60',
+              '-Itest',
+              'test/passing_test.rb',
+              chdir: 'test/fixtures/',
+            )
+          end
+        end.each(&:join)
+      end
+
+      assert_empty filter_deprecation_warnings(err)
+
+      Tempfile.open('warnings') do |warnings_file|
+        out, err = capture_subprocess_io do
+          system(
+            @exe, 'report',
+            '--queue', @redis_url,
+            '--build', '1',
+            '--timeout', '1',
+            '--warnings-file', warnings_file.path,
+            '--heartbeat',
+            chdir: 'test/fixtures/',
+          )
+        end
+
+        assert_empty filter_deprecation_warnings(err)
+        result = normalize(out.lines[1].strip)
+        assert_equal "Ran 100 tests, 100 assertions, 0 failures, 0 errors, 0 skips, 0 requeues in X.XXs (aggregated)", result
+        warnings = warnings_file.read.lines.map { |line| JSON.parse(line) }
+        assert_equal 0, warnings.size, "No tests should be stolen -- heartbeat cap should not have fired"
+      end
+    end
+
     def test_lazy_loading_streaming
       out, err = capture_subprocess_io do
         threads = 2.times.map do |i|