From 84a6eb66b0e7ea372bc52b1549a11bcf6edf6224 Mon Sep 17 00:00:00 2001 From: Andrei Kvapil Date: Fri, 3 Jul 2026 12:51:24 +0200 Subject: [PATCH] test(harness): raise CI Eventually scale x3->x5 for autoplace flake MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit The x3 CI budget stretch (30s->90s) still let the heaviest autoplace- convergence cases rotate-flake the Integration lane under full-suite contention: TestGroupFRToggleDiskful2DisklessReapsTieBreaker and TestGroupJ/CSICreateVolumeFromEmpty both timed out at exactly 90s on a loaded GitHub runner while completing in ~8s locally — CPU starvation, not a hang. Raise the scale to x5 (30s->150s) so the placer / mock- satellite reconcile loop gets more wall-clock under contention. Fail-safe: Eventually returns the instant the predicate passes, so green runs pay nothing for the larger budget; a genuinely stuck test still fails at the job-level -timeout=15m ceiling. Pin test updated to 150s. Signed-off-by: Andrei Kvapil Co-Authored-By: Claude --- tests/integration/harness/asserts.go | 11 ++++++++++- tests/integration/harness/asserts_ci_scale_test.go | 9 ++++++--- 2 files changed, 16 insertions(+), 4 deletions(-) diff --git a/tests/integration/harness/asserts.go b/tests/integration/harness/asserts.go index cb41fb04..1c187e6c 100644 --- a/tests/integration/harness/asserts.go +++ b/tests/integration/harness/asserts.go @@ -68,8 +68,17 @@ func Eventually(t *testing.T, timeout time.Duration, predicate func() bool, msg // positive-convergence asserts — it returns the moment the predicate // passes — so green runs pay nothing for the stretch; only genuinely // failing runs report slower, still capped by the job-level -timeout. +// +// ×3 (90s) still wasn't enough headroom for the heaviest autoplace- +// convergence cases under full-suite CI contention: GroupFR's +// ToggleDiskful2DisklessReapsTieBreaker and GroupJ's +// CSICreateVolumeFromEmpty both timed out at exactly 90s on a loaded +// runner while completing in ~8s locally — starvation, not a hang. The +// scale is ×5 (150s) to give the placer/mock-satellite reconcile loop +// more wall-clock under contention. A genuinely stuck test still fails +// the job at the -timeout=15m ceiling, and green runs still pay nothing. func scaledTimeout(timeout time.Duration) time.Duration { - const ciScale = 3 + const ciScale = 5 if os.Getenv("CI") == "" { return timeout diff --git a/tests/integration/harness/asserts_ci_scale_test.go b/tests/integration/harness/asserts_ci_scale_test.go index 28d77e8c..e7e642ad 100644 --- a/tests/integration/harness/asserts_ci_scale_test.go +++ b/tests/integration/harness/asserts_ci_scale_test.go @@ -28,12 +28,15 @@ import ( // TestScaledTimeoutStretchesOnCI pins the CI budget stretch: the // per-group convergence constants are tuned for dev machines, and the // Integration lane rotate-flaked on GitHub runners until Eventually -// budgets were scaled there (GroupI / GroupJ 30s timeouts). +// budgets were scaled there (GroupI / GroupJ 30s timeouts). The scale +// is ×5 (30s → 150s): ×3 (90s) still rotate-flaked the heaviest +// autoplace-convergence cases (GroupFR / GroupJ) under full-suite +// contention while they complete in ~8s locally. func TestScaledTimeoutStretchesOnCI(t *testing.T) { t.Setenv("CI", "true") - if got := scaledTimeout(30 * time.Second); got != 90*time.Second { - t.Fatalf("scaledTimeout on CI: got %s, want 90s", got) + if got := scaledTimeout(30 * time.Second); got != 150*time.Second { + t.Fatalf("scaledTimeout on CI: got %s, want 150s", got) } t.Setenv("CI", "")