From bf36db5b01fee6f53d71161df487dae2b3e1fed2 Mon Sep 17 00:00:00 2001 From: peptiderepo Date: Fri, 12 Jun 2026 14:59:43 +0000 Subject: [PATCH] =?UTF-8?q?fix(auth):=20survive=20ERR=5FABORTED=20in=20log?= =?UTF-8?q?in=20retry=20=E2=80=94=20recreate=20context,=205=20attempts=20w?= =?UTF-8?q?ith=20backoff?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit - Introduce safeClose() helper that ignores 'Target page, context or browser has been closed' errors. When Hostinger LiteSpeed aborts a connection (net::ERR_ABORTED), Playwright internally marks the context as closed; the previous bare context.close() threw from inside catch, propagating out and killing setup before remaining retries ran. - MAX_ATTEMPTS 3 → 5 for more tolerance of burst throttle windows. - Backoff changed from flat 15 s → exponential 5/10/20/40 s (75 s total). - Worst-case timing: 5 × 90 s nav + 75 s backoff = ~525 s < 900 s job limit. - Final-failure message explicitly names the LiteSpeed throttle hypothesis. - Version bump 1.2.0 → 1.3.0. Agent-Session: engineer-e2e-authfix-20260612 --- CHANGELOG.md | 20 +++++++++++++++++ global.setup.ts | 58 ++++++++++++++++++++++++++++++++++++++++--------- package.json | 2 +- 3 files changed, 69 insertions(+), 11 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 59c5a6f..9632ca0 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,6 +2,26 @@ All notable changes to the peptide-e2e smoke suite will be documented here. +## [1.3.0] - 2026-06-12 + +### Fixed +- **Auth setup survives `ERR_ABORTED` on wp-login.php** (`global.setup.ts`). + When Hostinger's LiteSpeed throttles a GitHub runner IP, `page.goto` can + throw `net::ERR_ABORTED` rather than a `TimeoutError`. Playwright marks the + browser context closed internally on abort, so the existing + `context.close()` call in the catch block threw + `"browserContext.close: Target page, context or browser has been closed"`, + which propagated out of catch and killed setup before the remaining retries + ran. Two production deploys were blocked by this flake on 2026-06-12. + + Fix: introduced `safeClose()` helper that swallows the already-closed + error, so an aborted context never terminates the retry loop. Max attempts + raised from 3 → 5; backoff is now exponential (5 s / 10 s / 20 s / 40 s) + instead of a flat 15 s, giving the throttle window more time to clear. + Worst-case timing: 5 × 90 s navigation + 75 s backoff = ~525 s, well under + the 900 s (15 min) job timeout. Final-failure message explicitly names the + LiteSpeed throttle hypothesis so future CI logs self-diagnose. + ## [1.2.0] - 2026-06-12 ### Added diff --git a/global.setup.ts b/global.setup.ts index 25aea31..c02ffd5 100755 --- a/global.setup.ts +++ b/global.setup.ts @@ -8,10 +8,25 @@ * The saved auth state (playwright/.auth/admin.json) is reused by the * "chromium" project so individual tests don't each incur a login round-trip. * - * Retry hardening (2026-06-12): Hostinger rate-limits GitHub runner IPs on + * Retry hardening (2026-06-12 v1): Hostinger rate-limits GitHub runner IPs on * wp-login.php, causing TimeoutError on page.goto. The login attempt is now * retried up to MAX_ATTEMPTS times with a fresh browser context per attempt * and BACKOFF_MS delay between attempts so transient throttle windows clear. + * + * Retry hardening (2026-06-12 v2 — ERR_ABORTED fix): When Hostinger aborts + * the connection (net::ERR_ABORTED), Playwright marks the context as closed + * internally. A subsequent context.close() call throws + * "browserContext.close: Target page, context or browser has been closed", + * which propagated out of the catch block and crashed setup without consuming + * remaining retries. Fix: context.close() is now guarded in its own + * try/catch so an already-closed context never aborts the retry loop. + * MAX_ATTEMPTS raised to 5; backoff doubled each time (5s/10s/20s/40s) so the + * LiteSpeed throttle window has time to clear before each retry. + * + * Timing math (job timeout-minutes: 15 = 900 s): + * 5 attempts × NAV_TIMEOUT (90 s) = 450 s navigation ceiling + * 4 inter-attempt waits (5+10+20+40 s) = 75 s backoff ceiling + * Total worst-case: ~525 s — well under the 900 s job timeout. */ import { test as setup, expect } from '@playwright/test'; @@ -20,9 +35,22 @@ import * as fs from 'fs'; const AUTH_FILE = path.join(__dirname, 'playwright/.auth/admin.json'); -const MAX_ATTEMPTS = 3; -const BACKOFF_MS = 15_000; // 15 s between attempts -const NAV_TIMEOUT = 90_000; // raised from 30 s → 90 s per attempt +const MAX_ATTEMPTS = 5; +const NAV_TIMEOUT = 90_000; // 90 s per navigation attempt + +/** Exponential backoff delays (ms) between attempts: 5 s, 10 s, 20 s, 40 s */ +function backoffMs(attempt: number): number { + return 5_000 * Math.pow(2, attempt - 1); +} + +/** Safely close a context that Playwright may have already closed internally. */ +async function safeClose(context: import('@playwright/test').BrowserContext): Promise { + try { + await context.close(); + } catch { + // Ignored: context was already closed (e.g. after ERR_ABORTED or crash). + } +} setup('authenticate as WP admin', async ({ browser }) => { const user = process.env.WP_ADMIN_USER; @@ -75,7 +103,7 @@ setup('authenticate as WP admin', async ({ browser }) => { await page.context().storageState({ path: AUTH_FILE }); console.log(`[setup] Login succeeded on attempt ${attempt}/${MAX_ATTEMPTS}`); - await context.close(); + await safeClose(context); return; // success — exit setup } catch (err) { lastError = err; @@ -84,11 +112,20 @@ setup('authenticate as WP admin', async ({ browser }) => { `[setup] Login attempt ${attempt}/${MAX_ATTEMPTS} FAILED: ${message}` ); - await context.close(); + // IMPORTANT: use safeClose — if Playwright received ERR_ABORTED it marks + // the context closed internally, so a plain context.close() throws + // "Target page, context or browser has been closed". Without this guard + // that secondary throw propagated out of catch and killed setup before + // the remaining retries ran. + await safeClose(context); if (attempt < MAX_ATTEMPTS) { - console.log(`[setup] Waiting ${BACKOFF_MS / 1000}s before retry ...`); - await new Promise((resolve) => setTimeout(resolve, BACKOFF_MS)); + const wait = backoffMs(attempt); + console.log( + `[setup] Waiting ${wait / 1000}s before retry ` + + `(LiteSpeed throttle cool-down — attempt ${attempt + 1}/${MAX_ATTEMPTS}) ...` + ); + await new Promise((resolve) => setTimeout(resolve, wait)); } } } @@ -97,7 +134,8 @@ setup('authenticate as WP admin', async ({ browser }) => { throw new Error( `[setup] All ${MAX_ATTEMPTS} login attempts failed. ` + `Last error: ${lastError instanceof Error ? lastError.message : String(lastError)}\n` + - `Hint: Hostinger may still be throttling GitHub runner IPs. ` + - `Re-run the workflow once the throttle window clears, or increase BACKOFF_MS / MAX_ATTEMPTS.` + `Hypothesis: Hostinger LiteSpeed is throttling GitHub runner IPs on wp-login.php — ` + + `connections abort (ERR_ABORTED) or time out in bursts. ` + + `Re-run the workflow once the throttle window clears, or increase MAX_ATTEMPTS / backoffMs().` ); }); diff --git a/package.json b/package.json index 060813b..045cb47 100755 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "peptide-e2e", - "version": "1.2.0", + "version": "1.3.0", "description": "Playwright smoke tests for peptiderepo.com (staging + production)", "private": true, "scripts": { -- 2.49.1