@camunda/e2e-test-suite 0.0.1270 → 0.0.1271

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camunda/e2e-test-suite",
-  "version": "0.0.1270",
+  "version": "0.0.1271",
   "description": "End-to-end test helpers for Camunda 8",
   "repository": {
     "type": "git",

package/playwright.config.ts

@@ -224,6 +224,83 @@ const changedFolders =
     ? args[changedFoldersArgIndex + 1].split(',')
     : [];
 
+// Run-budget guards. See the "A hung test is not an infrastructure failure"
+// note in docs/ci-failure-categories.md, and issue #3115.
+const isSmoke = process.env.IS_SMOKE === 'true';
+
+// Reads a numeric env override. An unset, empty, negative or unparseable value
+// returns undefined so the guard falls back to its default rather than being
+// silently switched off by a typo. An explicit 0 is honoured -- Playwright
+// reads 0 as "no limit" for both globalTimeout and maxFailures.
+const numericEnv = (name: string): number | undefined => {
+  const raw = process.env[name];
+  if (raw === undefined || raw.trim() === '') return undefined;
+  const value = Number(raw);
+  return Number.isFinite(value) && value >= 0 ? value : undefined;
+};
+
+// Without globalTimeout Playwright never stops itself, so one hung test costs
+// `timeout x (retries + 1)` -- 24 minutes at the 12-minute default -- and
+// GitHub SIGKILLs the job at its `timeout-minutes` before any report is
+// written. A run with no report has total_tests == 0, which
+// docs/ci-failure-categories.md classifies as
+// `infrastructure` -- a hung test gets filed as a platform problem and never
+// reaches anyone who can fix it. When Playwright owns the deadline instead it
+// runs its reporters first (runner/tasks.js finishTaskRun calls onEnd on every
+// status), so the run fails with a report naming the stuck test.
+//
+// The budget belongs to the caller: globalTimeout is only correct below the
+// job's `timeout-minutes`, and that differs per workflow. The smoke leg is the
+// one context this file can infer -- the blocking gate with the tightest
+// budget (25 minutes, camunda/camunda-platform-helm
+// .github/workflows/test-integration-runner.yaml), which a single hang already
+// exhausts. Every other caller opts in with C8E2E_GLOBAL_TIMEOUT_MIN. Jobs that
+// declare no `timeout-minutes` (this repo's nightlies, the repeat-each
+// validation loops that run for hours) have no budget to protect, so they keep
+// the unbounded behaviour.
+const SMOKE_GLOBAL_TIMEOUT_MINUTES = 20;
+
+const globalTimeout = () => {
+  const override = numericEnv('C8E2E_GLOBAL_TIMEOUT_MIN');
+  if (override !== undefined) return override * 60 * 1000;
+  return isSmoke ? SMOKE_GLOBAL_TIMEOUT_MINUTES * 60 * 1000 : undefined;
+};
+
+// The missing fail-fast lever: once the platform is down there is no value in
+// paying the per-test timeout for every remaining test. Smoke is a blocking
+// gate over a single spec, so the first failure is already the answer.
+//
+// Everywhere else the default stays 0 (no limit) on purpose. The nightly triage
+// dispatchers (.github/workflows/triage-nightly-failures*.yml) fan out one fix
+// agent per failing test and docs/ci-failure-categories.md derives
+// failure_category from the full counts, so truncating the failure list would
+// hide work rather than save time. Callers with a real budget set
+// C8E2E_MAX_FAILURES.
+const maxFailures = () => {
+  const override = numericEnv('C8E2E_MAX_FAILURES');
+  if (override !== undefined) return override;
+  return isSmoke ? 1 : 0;
+};
+
+// @playwright/test sets the context navigation timeout to 0 -- no limit --
+// whenever `navigationTimeout` is absent (playwright/lib/index.js
+// `_setupContextOptions`: `navigationTimeout || 0`), and TimeoutSettings
+// resolves that 0 before it ever falls through to `actionTimeout`. So today
+// every `goto`, `waitForURL` and `waitForLoadState` call that does not pass its
+// own `timeout` is bounded only by the 12-minute test timeout.
+//
+// That is the hang primitive: `waitForLoadState('networkidle')` waits for 500ms
+// of network silence that never arrives while a backend restarts and clients
+// retry, and the suite has 86 of those calls. Bounding navigation converts a
+// 12-minute stall into a 2-minute failure with a stack trace, without touching
+// the per-test budget that genuinely slow flows rely on.
+//
+// A call that passes its own `timeout` always wins, so nothing bounded today
+// becomes stricter; 120s matches the most generous explicit navigation timeout
+// the suite already uses.
+const NAVIGATION_TIMEOUT_MS =
+  numericEnv('C8E2E_NAVIGATION_TIMEOUT_MS') ?? 120 * 1000;
+
 const timeout = () => {
   if (process.env.MINOR_VERSION?.includes('SM-8.7')) {
     // OpenSearch indexes more slowly than Elasticsearch — give SM-8.7 the
@@ -268,6 +345,8 @@ export default defineConfig({
   // API specs into a browser project that has none of their environment.
   testIgnore: /[\\/]tests[\\/]api[\\/]/,
   timeout: timeout(),
+  globalTimeout: globalTimeout(),
+  maxFailures: maxFailures(),
   workers: workerCount(),
   retries: 1,
   fullyParallel: false,
@@ -275,6 +354,7 @@ export default defineConfig({
   use: {
     baseURL: getBaseURL(),
     actionTimeout: 10000,
+    navigationTimeout: NAVIGATION_TIMEOUT_MS,
     // Stage 5: trace on-first-retry. With retries=1, a passing-on-retry
     // test (i.e., a flake) leaves a trace from the first attempt — exactly
     // the cases worth debugging. Green runs pay no trace cost.