test: size the distributed test budget for a contended runner

The CockroachDB job timed out on two tests of distributedDatabaseTest.ts, both at
the 60s ceiling. Nothing was wrong with them: the whole job ran about three times
slower than the run fifteen minutes earlier on the same branch, down to the test
that only builds a schema and asserts its flags (9.2s, then 28.7s). CI brings up a
three-node cluster in docker alongside the suite on a shared two-core runner, so
that spread is the runner's, and a budget picked from the fast run reports timeouts
in place of the failures the compatibility jobs exist to catch. Distributed
backends get 120s, which covers the slow run at the observed spread.

The number lived in two files as a literal 60000, and the block override in
distributedDatabaseTest.ts caps the global rather than deferring to it, so raising
one alone would have changed nothing. Both now read test/timeouts.ts, which holds
the per-backend budget and the reasoning behind each value.

Author: kibertoad

test/distributedDatabaseTest.ts

@@ -1,6 +1,7 @@
 import { expect, it } from 'vitest'
 import * as helper from './testHelper.ts'
 import { ctx } from './hooks.ts'
+import { isDistributedBackend, distributedTimeout } from './timeouts.ts'
 
 // This file holds ONLY the invariants the general suite structurally cannot express. General
 // behavioral coverage (fetch/complete/fail/retry/policies/flows/dead-letter/...) already runs in
@@ -17,17 +18,15 @@ import { ctx } from './hooks.ts'
 //      noCoveringIndexes / noAdvisoryLocks) — the ONLY Postgres-side coverage of that DDL, since the
 //      `DISTRIBUTED=true` job sets noSkipLocked + noMultiMutationCte but NOT the schema no* flags.
 //
-// Every test here calls helper.start(), which on CockroachDB pays slow per-test DDL (~8-9s observed
-// in CI), leaving little headroom under the 10s global timeout. Raise the default for the whole
-// block so startup jitter can't push a test over the edge (the concurrency tests keep their explicit
-// per-test overrides).
+// Every test here calls helper.start(), which on CockroachDB pays slow per-test DDL, leaving little
+// headroom under the 10s Postgres global. Raise the default for the whole block so startup jitter
+// can't push a test over the edge (the concurrency tests keep their explicit per-test overrides).
 //
-// The override must only LIFT the Postgres budget — never cap a distributed backend. vitest.config.ts
-// already gives cockroachdb/yugabytedb a 60s global; a flat 20s here would lower it for exactly the
-// heaviest tests (the withTransaction composition tests do slow DDL + an extra connection), which is
-// how they timed out at 20s on the CockroachDB run. So match that 60s on distributed backends.
-const isDistributedBackend = process.env.DB_TYPE === 'cockroachdb' || process.env.DB_TYPE === 'yugabytedb'
-const blockTimeout = isDistributedBackend ? 60000 : 20000
+// The override must only LIFT the Postgres budget, never cap a distributed backend: a per-test or
+// per-block value replaces the global in both directions, so a flat 20s here would lower it for
+// exactly the heaviest tests (the withTransaction composition tests do slow DDL plus an extra
+// connection). A distributed backend keeps the budget test/timeouts.ts sets for it.
+const blockTimeout = isDistributedBackend ? distributedTimeout : 20000
 
 // The concurrency tests need more than the block default on Postgres, so they carry their own
 // override - which has to follow the same rule, since a per-test value replaces the block value in

test/timeouts.ts

@@ -0,0 +1,17 @@
+// The per-backend test budget, in one place: vitest.config.ts reads it for the global default, and
+// so does every suite that raises the default for a block of its own. Both sides have to agree,
+// because a per-block value replaces the global in either direction and a block that names its own
+// number caps the backend that needs the most room.
+
+export const isDistributedBackend = process.env.DB_TYPE === 'cockroachdb' || process.env.DB_TYPE === 'yugabytedb'
+
+// PostgreSQL finishes a test's schema setup in well under a second, so 10s is generous and keeps a
+// hung test cheap to find.
+export const postgresTimeout = 10000
+
+// CockroachDB and YugabyteDB pay heavy online-DDL/schema-rebuild costs per test, so they get a
+// budget sized for a contended runner rather than a good one: CI brings up a three-node CockroachDB
+// cluster in docker alongside the suite on a shared two-core runner, where the same tests that each
+// take ~9s on one run take ~30s on the next. The budget has to cover the slow run, or the
+// compatibility jobs report timeouts in place of the failures they exist to catch.
+export const distributedTimeout = 120000

vitest.config.ts

@@ -1,16 +1,13 @@
 import { defineConfig } from 'vitest/config'
+import { isDistributedBackend, distributedTimeout, postgresTimeout } from './test/timeouts.ts'
 
-// CockroachDB and YugabyteDB pay heavy online-DDL/schema-rebuild costs per test, which blow the
-// PostgreSQL-tuned 10s budget. Give the whole suite more headroom when running against a distributed
-// backend so the compatibility runs report real failures instead of timeouts.
-const isDistributedBackend = process.env.DB_TYPE === 'cockroachdb' || process.env.DB_TYPE === 'yugabytedb'
-const testTimeout = isDistributedBackend ? 60000 : 10000
-const hookTimeout = isDistributedBackend ? 60000 : 10000
+// See test/timeouts.ts for why a distributed backend gets a budget of its own.
+const timeout = isDistributedBackend ? distributedTimeout : postgresTimeout
 
 export default defineConfig({
   test: {
-    testTimeout,
-    hookTimeout,
+    testTimeout: timeout,
+    hookTimeout: timeout,
     include: ['test/**/*Test.ts'],
     globalSetup: ['./test/checkDuplicateTestNames.ts'],
     setupFiles: ['./test/hooks.ts'],