test(js-sdk): wait for workers.dev propagation in the CF deploy suite (#1592)

mishushakov · claude · web-flow · commit 4a2571d32187 · 2026-07-30T09:30:43.000-07:00
## Problem The `cloudflare-deploy` CI job intermittently fails with `non-JSON response (404): <!DOCTYPE html>...` ([example run](https://github.com/e2b-dev/E2B/actions/runs/30009788154/job/89214641280)). The truncated HTML boilerplate is easy to mistake for a Cloudflare captcha/challenge page, but it's the standard Cloudflare **404** page: each `wrangler deploy --temporary` lands on a brand-new account subdomain (`e2b-js-sdk-smoke.<random>.workers.dev`), and Cloudflare serves "nothing is here yet" until the route propagates to the edge. The in-test retry window (initial attempt + 10 retries × 3s ≈ 35s) wasn't always enough. ## Fix - `setup.mts`: after the deploy, poll the worker URL until the worker itself answers (405 to GET — the worker is POST-only), with a 240s deadline. Tests only start once the route is live. Only the propagation 404 and thrown fetch errors (transient DNS/connect) keep the poll waiting — any other status (403 challenge, 500 from a broken worker, ...) is a real failure and fails the setup immediately, with the error page's `<title>` in the message. - `run.test.ts`: retry only on the propagation 404 / `fetch failed`, so other Cloudflare error pages propagate on the first attempt; include the page `<title>` in the `non-JSON response` error, since the truncated body is boilerplate shared by every Cloudflare error page. Test-only change, no changeset. ## Verification Ran `pnpm test:cf:deploy` against real Cloudflare (both revisions): ``` Deployed: https://e2b-js-sdk-smoke.quick-bike.workers.dev Worker route not live yet (404), waiting... Worker route not live yet (404), waiting... Worker is live. Test Files 1 passed (1) Tests 1 passed (1) ``` The fresh subdomain served 404 for ~6s post-deploy — exactly the failure mode from CI — then the suite passed on the first test attempt. `pnpm run format`, `lint`, and `typecheck` pass. 🤖 Generated with [Claude Code](https://claude.com/claude-code) --------- Co-authored-by: Claude Fable 5 <noreply@anthropic.com>
diff --git a/packages/js-sdk/tests/runtimes/cloudflare-deploy/run.test.ts b/packages/js-sdk/tests/runtimes/cloudflare-deploy/run.test.ts
@@ -4,15 +4,15 @@ import { template } from '../../template'
 
 test(
   'sandbox lifecycle inside a deployed Cloudflare Worker',
-  // Retry the whole test while the fresh workers.dev subdomain propagates:
-  // Cloudflare serves an HTML error page until the route is live ("non-JSON
-  // response"), and fetch itself can fail at the DNS/connect level first
-  // (undici throws "fetch failed").
+  // setup.mts waits for the fresh workers.dev subdomain to propagate before
+  // tests run; these retries only absorb transient blips — a stray
+  // propagation 404 or an undici DNS/connect error ("fetch failed"). Any
+  // other Cloudflare error page is a real failure and propagates.
   {
     retry: {
       count: 10,
       delay: 3_000,
-      condition: /non-JSON response|fetch failed/,
+      condition: /non-JSON response \(404|fetch failed/,
     },
   },
   async () => {
@@ -35,10 +35,14 @@ test(
     try {
       body = JSON.parse(text)
     } catch {
-      // Cloudflare edge error page (e.g. DNS still propagating) — fail and
-      // let the retry kick in.
+      // Cloudflare edge error page — fail and let the retry kick in. The
+      // page's <title> says which error it is (the truncated body is just
+      // boilerplate shared by every Cloudflare error page).
+      const title = text.match(/<title>(.*?)<\/title>/is)?.[1]?.trim()
       throw new Error(
-        `non-JSON response (${response.status}): ${text.slice(0, 200)}`
+        `non-JSON response (${response.status}${
+          title ? `, "${title}"` : ''
+        }): ${text.slice(0, 200)}`
       )
     }
 
diff --git a/packages/js-sdk/tests/runtimes/cloudflare-deploy/setup.mts b/packages/js-sdk/tests/runtimes/cloudflare-deploy/setup.mts
@@ -30,7 +30,47 @@ function wrangler(args: string[]) {
   return { ...result, output: `${result.stdout ?? ''}\n${result.stderr ?? ''}` }
 }
 
-export default function setup(project: TestProject) {
+// A temporary deploy lands on a brand-new account subdomain
+// (<worker>.<random-name>.workers.dev), and Cloudflare serves its HTML 404
+// page ("nothing is here yet") until the route propagates to the edge —
+// usually seconds, occasionally minutes. Wait for the worker itself to
+// answer (405 to GET, worker.mjs is POST-only) so the test's own retries
+// only have to absorb transient network failures.
+async function waitUntilLive(workerUrl: string, timeoutMs = 240_000) {
+  const deadline = Date.now() + timeoutMs
+  for (;;) {
+    // Thrown fetch errors (DNS/connect for the fresh subdomain) are also
+    // transient — keep waiting on those, but fail fast on any status other
+    // than the propagation 404 so real errors surface immediately.
+    const response = await fetch(workerUrl).catch((err) => {
+      console.log(`Worker not reachable yet (${err}), waiting...`)
+      return undefined
+    })
+    if (response) {
+      if (response.status === 405) {
+        return
+      }
+      if (response.status !== 404) {
+        const text = await response.text()
+        const title = text.match(/<title>(.*?)<\/title>/is)?.[1]?.trim()
+        throw new Error(
+          `Worker at ${workerUrl} answered ${response.status}${
+            title ? ` ("${title}")` : ''
+          } — not the propagation 404: ${text.slice(0, 200)}`
+        )
+      }
+      console.log('Worker route not live yet (404), waiting...')
+    }
+    if (Date.now() >= deadline) {
+      throw new Error(
+        `Worker at ${workerUrl} did not come up within ${timeoutMs / 1000}s of deploy`
+      )
+    }
+    await new Promise((resolve) => setTimeout(resolve, 3_000))
+  }
+}
+
+export default async function setup(project: TestProject) {
   rmSync(outputFile, { force: true })
 
   console.log('Deploying worker to a temporary Cloudflare preview account...')
@@ -58,6 +98,8 @@ export default function setup(project: TestProject) {
   }
 
   console.log(`Deployed: ${workerUrl}`)
+  await waitUntilLive(workerUrl)
+  console.log('Worker is live.')
   project.provide('cfWorkerUrl', workerUrl)
 
   return function teardown() {
