The best way to control Claude Code, Codex and more from any computer or phone
Mirrored from https://github.com/Camo67/t3code.git
Synced Nov 21, 06:00 UTC
| 1 | import * as Cloudflare from "@alchemy.run/cloudflare"; |
| 2 | import { describe, expect } from "@alchemy.run/test"; |
| 3 | import * as Test from "@alchemy.run/test/Alchemy"; |
| 4 | import * as Effect from "effect/Effect"; |
| 5 | import * as HttpClientRequest from "effect/http/HttpClientRequest"; |
| 6 | import * as Schedule from "effect/Schedule"; |
| 7 | import { requestWorker } from "../Utils/WorkerRequest.ts"; |
| 8 | import type { MigrationProbe, Snapshot } from "./fixtures/alarm-upgrade/types.ts"; |
| 9 | import AlarmUpgradeWorker from "./fixtures/alarm-upgrade/v2.ts"; |
| 10 | |
| 11 | class WorkerVersionPending extends Error {} |
| 12 | |
| 13 | const requestJson = Effect.fn( |
| 14 | function* (url: string, action = "snapshot", workerVersion: Snapshot["version"] = "v2") { |
| 15 | const fresh = yield* Effect.sync(() => { |
| 16 | const fresh = new URL(`${url}/${action}`); |
| 17 | fresh.searchParams.set("cb", String(Date.now())); |
| 18 | return fresh; |
| 19 | }); |
| 20 | const response = yield* requestWorker( |
| 21 | (fresh.pathname === "/snapshot" |
| 22 | ? HttpClientRequest.get(fresh.href) |
| 23 | : HttpClientRequest.post(fresh.href) |
| 24 | ).pipe( |
| 25 | // A fresh connection avoids polling an edge still pinned to the old deployment. |
| 26 | HttpClientRequest.setHeaders({ |
| 27 | connection: "close", |
| 28 | "cache-control": "no-cache", |
| 29 | "x-alarm-worker-version": workerVersion, |
| 30 | }), |
| 31 | ), |
| 32 | ).pipe(Effect.timeout("15 seconds")); |
| 33 | if (response.status !== 200) { |
| 34 | const body = yield* response.text; |
| 35 | const actualVersion = response.headers["x-alarm-worker-version"]; |
| 36 | if ( |
| 37 | response.status === 409 && |
| 38 | actualVersion === (workerVersion === "v1" ? "v2" : "v1") && |
| 39 | body === "Alarm worker version mismatch" |
| 40 | ) { |
| 41 | return yield* Effect.fail( |
| 42 | new WorkerVersionPending(`Waiting for Worker ${workerVersion}; got ${actualVersion}`), |
| 43 | ); |
| 44 | } |
| 45 | return yield* Effect.fail( |
| 46 | new Error(`Upgrade fixture ${action}: HTTP ${response.status}\n${body}`), |
| 47 | ); |
| 48 | } |
| 49 | const body: unknown = yield* response.json; |
| 50 | return body; |
| 51 | }, |
| 52 | Effect.retry({ |
| 53 | while: (error) => error instanceof WorkerVersionPending, |
| 54 | schedule: Schedule.spaced("1 second"), |
| 55 | times: 10, |
| 56 | }), |
| 57 | ); |
| 58 | |
| 59 | const request = (url: string, action = "snapshot", workerVersion: Snapshot["version"] = "v2") => |
| 60 | requestJson(url, action, workerVersion).pipe(Effect.map((body) => body as Snapshot)); |
| 61 | |
| 62 | const ready = (url: string, version: Snapshot["version"], name?: string) => |
| 63 | request( |
| 64 | url, |
| 65 | name === undefined ? "snapshot" : `snapshot?name=${encodeURIComponent(name)}`, |
| 66 | version, |
| 67 | ).pipe( |
| 68 | Effect.flatMap((snapshot) => |
| 69 | snapshot.version === version |
| 70 | ? Effect.succeed(snapshot) |
| 71 | : Effect.fail(new Error(`Waiting for ${version}; got ${snapshot.version}`)), |
| 72 | ), |
| 73 | Effect.retry({ schedule: Schedule.spaced("3 seconds"), times: 10 }), |
| 74 | ); |
| 75 | |
| 76 | /** |
| 77 | * Wait for a redeploy to reach the live Durable Object. A Worker deploy that |
| 78 | * carries no Durable Object lifecycle change (declarative `exports`, no |
| 79 | * migration) does not restart a running object: Cloudflare keeps an |
| 80 | * activation that keeps receiving requests on the previous code — measured: |
| 81 | * polling every 3s still reached V1 150s after the V2 deploy — and only |
| 82 | * starts the new code once the object has been idle (~20s). So the first |
| 83 | * probe after the upgrade must come after an idle gap, and so must every |
| 84 | * retry. Local restarts are atomic, so dev mode needs no gap. |
| 85 | */ |
| 86 | const readyAfterRollout = (url: string, dev: boolean) => |
| 87 | dev |
| 88 | ? ready(url, "v2") |
| 89 | : Effect.sleep("25 seconds").pipe( |
| 90 | Effect.andThen( |
| 91 | request(url).pipe( |
| 92 | Effect.flatMap((snapshot) => |
| 93 | snapshot.version === "v2" |
| 94 | ? Effect.succeed(snapshot) |
| 95 | : Effect.fail(new Error(`Waiting for v2; got ${snapshot.version}`)), |
| 96 | ), |
| 97 | Effect.retry({ schedule: Schedule.spaced("25 seconds"), times: 2 }), |
| 98 | ), |
| 99 | ), |
| 100 | ); |
| 101 | |
| 102 | const delivered = ( |
| 103 | url: string, |
| 104 | until: (snapshot: Snapshot) => boolean, |
| 105 | workerVersion: Snapshot["version"] = "v2", |
| 106 | ) => |
| 107 | request(url, "snapshot", workerVersion).pipe( |
| 108 | Effect.repeat({ schedule: Schedule.spaced("1 second"), times: 10, until }), |
| 109 | Effect.tap((snapshot) => Effect.sync(() => expect(until(snapshot)).toBe(true))), |
| 110 | ); |
| 111 | |
| 112 | const count = (snapshot: Snapshot, channel: "legacy" | "callback", id: string) => |
| 113 | snapshot.deliveries.filter((delivery) => delivery.channel === channel && delivery.id === id) |
| 114 | .length; |
| 115 | |
| 116 | for (const dev of [true, false]) { |
| 117 | describe( |
| 118 | dev ? "local alarm upgrade" : "live alarm upgrade", |
| 119 | { tags: ["provider:cloudflare", "provider:cloudflare:worker"] }, |
| 120 | () => { |
| 121 | const { test } = Test.make({ providers: Cloudflare.providers(), dev }); |
| 122 | |
| 123 | test.provider( |
| 124 | `${dev ? "local" : "live"} V1 to V2 deployment preserves legacy schema, jobs and object identity`, |
| 125 | (stack) => |
| 126 | Effect.gen(function* () { |
| 127 | yield* stack.destroy(); |
| 128 | const main = yield* Effect.sync( |
| 129 | () => new URL("./fixtures/alarm-upgrade/v1.ts", import.meta.url).pathname, |
| 130 | ); |
| 131 | const originalDeployment = yield* stack.deploy( |
| 132 | Effect.gen(function* () { |
| 133 | const host = yield* Cloudflare.Worker("AlarmUpgradeWorker", { |
| 134 | main, |
| 135 | env: { UpgradeObject: Cloudflare.DurableObject("UpgradeObject") }, |
| 136 | }); |
| 137 | const reader = dev |
| 138 | ? undefined |
| 139 | : yield* Cloudflare.Worker("AlarmUpgradeV1Reader", { |
| 140 | main, |
| 141 | env: { |
| 142 | UpgradeObject: Cloudflare.DurableObject("UpgradeObject", { |
| 143 | scriptName: host.workerName, |
| 144 | }), |
| 145 | }, |
| 146 | }); |
| 147 | return { host, reader }; |
| 148 | }), |
| 149 | ); |
| 150 | const original = originalDeployment.host; |
| 151 | expect(original.url).toBeDefined(); |
| 152 | expect(original.durableObjectNamespaces.UpgradeObject).toBeDefined(); |
| 153 | if (dev) { |
| 154 | expect(original.url).toMatch(/^http:\/\/localhost:\d+$/); |
| 155 | } else { |
| 156 | expect(original.url).toMatch(/^https:\/\//); |
| 157 | } |
| 158 | const initial = yield* ready(original.url!, "v1"); |
| 159 | expect(initial.marker).toBeNull(); |
| 160 | yield* request(original.url!, "seed", "v1"); |
| 161 | yield* ready(original.url!, "v1", "future-version"); |
| 162 | const futureOriginal = yield* request(original.url!, "seed?name=future-version", "v1"); |
| 163 | yield* ready(original.url!, "v1", "atomic-migration"); |
| 164 | const rollbackOriginal = yield* request( |
| 165 | original.url!, |
| 166 | "seed?name=atomic-migration", |
| 167 | "v1", |
| 168 | ); |
| 169 | for (const seeded of [futureOriginal, rollbackOriginal]) { |
| 170 | expect(seeded.tables).toEqual(["alchemy_scheduled_events"]); |
| 171 | expect(seeded.schemaVersion).toBeNull(); |
| 172 | expect(seeded.schemaRows).toEqual([]); |
| 173 | expect(seeded.legacyRows).toHaveLength(3); |
| 174 | } |
| 175 | const before = yield* delivered( |
| 176 | original.url!, |
| 177 | (snapshot) => |
| 178 | count(snapshot, "legacy", "v1-proof") === 1 && |
| 179 | snapshot.legacyRows.length === 3 && |
| 180 | snapshot.alarm === Math.min(...snapshot.legacyRows.map((row) => row.run_at)), |
| 181 | "v1", |
| 182 | ); |
| 183 | expect(before.version).toBe("v1"); |
| 184 | expect(before.marker).toBe("written-by-v1"); |
| 185 | expect(before.tables).toEqual(["alchemy_scheduled_events"]); |
| 186 | expect(before.schemaVersion).toBeNull(); |
| 187 | expect(before.schemaRows).toEqual([]); |
| 188 | expect(before.legacyRows.map((row) => row.id)).toEqual([ |
| 189 | "legacy-cancel", |
| 190 | "legacy-one", |
| 191 | "legacy-repeat", |
| 192 | ]); |
| 193 | expect(before.legacyColumns).toEqual([ |
| 194 | { name: "id", type: "TEXT", notnull: 0, pk: 1 }, |
| 195 | { name: "run_at", type: "INTEGER", notnull: 1, pk: 0 }, |
| 196 | { name: "repeat_ms", type: "INTEGER", notnull: 0, pk: 0 }, |
| 197 | { name: "payload", type: "TEXT", notnull: 1, pk: 0 }, |
| 198 | ]); |
| 199 | expect(before.alarm).toBe(Math.min(...before.legacyRows.map((row) => row.run_at))); |
| 200 | expect(before.deliveries).toEqual([ |
| 201 | { |
| 202 | version: "v1", |
| 203 | channel: "legacy", |
| 204 | id: "v1-proof", |
| 205 | payload: { callback: "archive", value: "v1-proof" }, |
| 206 | }, |
| 207 | ]); |
| 208 | |
| 209 | // This is an update of the existing resource, not a fresh namespace or a schema-only fixture. |
| 210 | const upgradedDeployment = yield* stack.deploy( |
| 211 | Effect.gen(function* () { |
| 212 | const host = yield* AlarmUpgradeWorker; |
| 213 | const reader = dev |
| 214 | ? undefined |
| 215 | : yield* Cloudflare.Worker("AlarmUpgradeV1Reader", { |
| 216 | main, |
| 217 | env: { |
| 218 | UpgradeObject: Cloudflare.DurableObject("UpgradeObject", { |
| 219 | scriptName: host.workerName, |
| 220 | }), |
| 221 | }, |
| 222 | }); |
| 223 | return { host, reader }; |
| 224 | }), |
| 225 | ); |
| 226 | const upgraded = upgradedDeployment.host; |
| 227 | expect(upgraded.workerName).toBe(original.workerName); |
| 228 | expect(upgraded.workerId).toBe(original.workerId); |
| 229 | expect(upgraded.durableObjectNamespaces.UpgradeObject).toBe( |
| 230 | original.durableObjectNamespaces.UpgradeObject, |
| 231 | ); |
| 232 | const after = yield* readyAfterRollout(upgraded.url!, dev); |
| 233 | expect(after.id).toBe(before.id); |
| 234 | expect(after.marker).toBe(before.marker); |
| 235 | expect(after.constructors).toContain("v1"); |
| 236 | expect(after.constructors).toContain("v2"); |
| 237 | expect(after.legacyColumns).toEqual(before.legacyColumns); |
| 238 | expect(after.legacyRows).toEqual(before.legacyRows); |
| 239 | expect(after.deliveries).toEqual(before.deliveries); |
| 240 | expect(after.alarm).toBe(before.alarm); |
| 241 | expect(after.tables).toContain("alchemy_scheduled_events"); |
| 242 | expect(after.tables).toContain("alchemy_alarm_callbacks"); |
| 243 | expect(after.tables).toContain("alchemy_alarm_schema"); |
| 244 | expect(after.schemaVersion).toBe(2); |
| 245 | expect(after.schemaRows).toEqual([{ id: 1, version: 2 }]); |
| 246 | expect(after.callbacks).toEqual([]); |
| 247 | if (upgradedDeployment.reader) { |
| 248 | // Local restarts are atomic; live edges can still run V1 against the V2 object. |
| 249 | const viaV1 = yield* request(upgradedDeployment.reader.url!, "snapshot", "v1"); |
| 250 | expect(viaV1).toEqual(after); |
| 251 | const rejected = yield* requestWorker( |
| 252 | HttpClientRequest.post(`${upgradedDeployment.reader.url!}/callback-first`).pipe( |
| 253 | HttpClientRequest.setHeader("x-alarm-worker-version", "v2"), |
| 254 | ), |
| 255 | ); |
| 256 | expect(rejected.status).toBe(409); |
| 257 | expect(rejected.headers["x-alarm-worker-version"]).toBe("v1"); |
| 258 | expect(yield* rejected.text).toBe("Alarm worker version mismatch"); |
| 259 | expect(yield* request(upgraded.url!)).toEqual(after); |
| 260 | } |
| 261 | |
| 262 | const callbackFirst = yield* request(upgraded.url!, "callback-first"); |
| 263 | expect(callbackFirst.callbacks).toHaveLength(1); |
| 264 | expect(callbackFirst.alarm).toBe(callbackFirst.callbacks[0].run_at); |
| 265 | expect(callbackFirst.alarm!).toBeLessThan(before.alarm!); |
| 266 | const reset = (yield* requestJson(upgraded.url!, "reconstruct")) as { |
| 267 | aborted: boolean; |
| 268 | }; |
| 269 | expect(reset.aborted).toBe(true); |
| 270 | const reconstructed = yield* ready(upgraded.url!, "v2"); |
| 271 | expect(reconstructed.constructors.length).toBeGreaterThan( |
| 272 | callbackFirst.constructors.length, |
| 273 | ); |
| 274 | expect(reconstructed.id).toBe(before.id); |
| 275 | expect(reconstructed.marker).toBe(before.marker); |
| 276 | expect(reconstructed.schemaVersion).toBe(2); |
| 277 | expect(reconstructed.schemaRows).toEqual([{ id: 1, version: 2 }]); |
| 278 | expect(reconstructed.schema).toEqual(callbackFirst.schema); |
| 279 | expect(reconstructed.legacyRows).toEqual(callbackFirst.legacyRows); |
| 280 | expect(reconstructed.callbacks).toEqual(callbackFirst.callbacks); |
| 281 | expect(reconstructed.alarm).toBe(callbackFirst.alarm); |
| 282 | const repeated = yield* request(upgraded.url!); |
| 283 | expect(repeated.schemaVersion).toBe(2); |
| 284 | expect(repeated.schemaRows).toEqual(reconstructed.schemaRows); |
| 285 | expect(repeated.schema).toEqual(reconstructed.schema); |
| 286 | expect(repeated.legacyRows).toEqual(reconstructed.legacyRows); |
| 287 | expect(repeated.callbacks).toEqual(reconstructed.callbacks); |
| 288 | expect(repeated.alarm).toBe(reconstructed.alarm); |
| 289 | const legacyCanceled = yield* request(upgraded.url!, "cancel-legacy"); |
| 290 | expect(legacyCanceled.legacyRows.map((row) => row.id)).toEqual([ |
| 291 | "legacy-one", |
| 292 | "legacy-repeat", |
| 293 | ]); |
| 294 | expect(legacyCanceled.callbacks).toEqual(callbackFirst.callbacks); |
| 295 | expect(legacyCanceled.alarm).toBe(callbackFirst.alarm); |
| 296 | const callbackCanceled = yield* request(upgraded.url!, "cancel-callback"); |
| 297 | expect(callbackCanceled.callbacks).toEqual([]); |
| 298 | expect(callbackCanceled.legacyRows).toEqual(legacyCanceled.legacyRows); |
| 299 | expect(callbackCanceled.alarm).toBe(before.alarm); |
| 300 | |
| 301 | // Pending jobs start five minutes ahead so deployment latency cannot consume them in V1. |
| 302 | // Moving only their due times forward keeps the native-alarm assertion bounded. |
| 303 | const released = yield* request(upgraded.url!, "release"); |
| 304 | expect(released.callbacks).toHaveLength(1); |
| 305 | expect(released.alarm).toBe(released.callbacks[0].run_at); |
| 306 | for (const row of released.legacyRows) { |
| 307 | const old = before.legacyRows.find((event) => event.id === row.id)!; |
| 308 | expect(row.payload).toBe(old.payload); |
| 309 | expect(row.repeat_ms).toBe(old.repeat_ms); |
| 310 | expect(row.run_at).toBe(released.callbacks[0].run_at); |
| 311 | } |
| 312 | const fired = yield* delivered( |
| 313 | upgraded.url!, |
| 314 | (snapshot) => |
| 315 | count(snapshot, "legacy", "legacy-one") === 1 && |
| 316 | count(snapshot, "legacy", "legacy-repeat") >= 2 && |
| 317 | count(snapshot, "callback", "new-callback") === 1 && |
| 318 | snapshot.callbacks.length === 0 && |
| 319 | snapshot.legacyRows.length === 1 && |
| 320 | snapshot.alarm === snapshot.legacyRows[0].run_at, |
| 321 | ); |
| 322 | expect(fired.legacyRows).toHaveLength(1); |
| 323 | expect(fired.legacyRows[0].id).toBe("legacy-repeat"); |
| 324 | expect(fired.legacyRows[0].repeat_ms).toBe(2_000); |
| 325 | expect(fired.legacyRows[0].run_at).toBeGreaterThan( |
| 326 | released.legacyRows.find((row) => row.id === "legacy-repeat")!.run_at, |
| 327 | ); |
| 328 | expect(fired.callbacks).toEqual([]); |
| 329 | expect(fired.alarm).toBe(fired.legacyRows[0].run_at); |
| 330 | for (const delivery of fired.deliveries.filter((event) => event.id !== "v1-proof")) { |
| 331 | expect(delivery.version).toBe("v2"); |
| 332 | if (delivery.channel === "legacy") { |
| 333 | expect(delivery.payload).toEqual({ callback: "archive", value: delivery.id }); |
| 334 | } |
| 335 | } |
| 336 | expect(count(fired, "legacy", "legacy-cancel")).toBe(0); |
| 337 | expect(fired.deliveries.filter((event) => event.channel === "callback")).toEqual([ |
| 338 | { |
| 339 | version: "v2", |
| 340 | channel: "callback", |
| 341 | id: "new-callback", |
| 342 | payload: { value: "new-callback" }, |
| 343 | }, |
| 344 | ]); |
| 345 | |
| 346 | const onlyCallback = yield* request(upgraded.url!, "only-callback"); |
| 347 | expect(onlyCallback.legacyRows).toEqual([]); |
| 348 | expect(onlyCallback.callbacks).toHaveLength(1); |
| 349 | expect(onlyCallback.alarm).toBe(onlyCallback.callbacks[0].run_at); |
| 350 | const callbackSurvived = yield* delivered( |
| 351 | upgraded.url!, |
| 352 | (snapshot) => |
| 353 | count(snapshot, "callback", "callback-survivor") === 1 && |
| 354 | snapshot.callbacks.length === 0 && |
| 355 | snapshot.alarm === null, |
| 356 | ); |
| 357 | expect(callbackSurvived.callbacks).toEqual([]); |
| 358 | expect(callbackSurvived.alarm).toBeNull(); |
| 359 | |
| 360 | const onlyLegacy = yield* request(upgraded.url!, "only-legacy"); |
| 361 | expect(onlyLegacy.callbacks).toEqual([]); |
| 362 | expect(onlyLegacy.legacyRows).toHaveLength(1); |
| 363 | expect(onlyLegacy.alarm).toBe(onlyLegacy.legacyRows[0].run_at); |
| 364 | const legacySurvived = yield* delivered( |
| 365 | upgraded.url!, |
| 366 | (snapshot) => |
| 367 | count(snapshot, "legacy", "legacy-survivor") === 1 && |
| 368 | snapshot.legacyRows.length === 0 && |
| 369 | snapshot.alarm === null, |
| 370 | ); |
| 371 | expect(count(legacySurvived, "callback", "must-not-fire")).toBe(0); |
| 372 | expect(count(legacySurvived, "callback", "canceled-callback")).toBe(0); |
| 373 | expect(count(legacySurvived, "legacy", "legacy-cancel")).toBe(0); |
| 374 | expect(legacySurvived.legacyRows).toEqual([]); |
| 375 | expect(legacySurvived.callbacks).toEqual([]); |
| 376 | expect(legacySurvived.alarm).toBeNull(); |
| 377 | expect(legacySurvived.id).toBe(before.id); |
| 378 | expect(legacySurvived.marker).toBe("written-by-v1"); |
| 379 | |
| 380 | const future = (yield* requestJson( |
| 381 | upgraded.url!, |
| 382 | "migration-future?name=future-version", |
| 383 | )) as MigrationProbe; |
| 384 | expect(future.before.id).toBe(futureOriginal.id); |
| 385 | expect(future.before.legacyRows).toEqual(futureOriginal.legacyRows); |
| 386 | expect(future.before.schemaVersion).toBe(3); |
| 387 | expect(future.before.schemaRows).toEqual([{ id: 1, version: 3 }]); |
| 388 | expect(future.before.callbacks).toHaveLength(1); |
| 389 | expect(future.before.alarm).toBe(futureOriginal.alarm); |
| 390 | expect(future.failure?.tag).toBe("UnsupportedAlarmSchemaVersion"); |
| 391 | expect(future.failure?.version).toBe(3); |
| 392 | expect(future.failure?.supportedVersion).toBe(2); |
| 393 | expect(future.after).toEqual(future.before); |
| 394 | expect(future.recovered).toBeNull(); |
| 395 | |
| 396 | const rollback = (yield* requestJson( |
| 397 | upgraded.url!, |
| 398 | "migration-rollback?name=atomic-migration", |
| 399 | )) as MigrationProbe; |
| 400 | expect(rollback.before.id).toBe(rollbackOriginal.id); |
| 401 | expect(rollback.before.legacyRows).toEqual(rollbackOriginal.legacyRows); |
| 402 | expect(rollback.before.schemaVersion).toBeNull(); |
| 403 | expect(rollback.before.schemaRows).toEqual([]); |
| 404 | expect(rollback.before.tables).not.toContain("alchemy_alarm_callbacks"); |
| 405 | expect(rollback.before.tables).not.toContain("alchemy_alarm_schema"); |
| 406 | expect( |
| 407 | rollback.before.schema.some( |
| 408 | (row) => row.name === "idx_alchemy_scheduled_events_run_at", |
| 409 | ), |
| 410 | ).toBe(false); |
| 411 | expect(rollback.failure).not.toBeNull(); |
| 412 | expect(rollback.failure!.message).toContain("idx_alchemy_alarm_callbacks_run_at"); |
| 413 | expect(rollback.after).toEqual(rollback.before); |
| 414 | expect(rollback.after.alarm).toBe(rollbackOriginal.alarm); |
| 415 | expect(rollback.retryBefore?.schemaVersion).toBe(0); |
| 416 | expect(rollback.retryBefore?.schemaRows).toEqual([{ id: 1, version: 0 }]); |
| 417 | expect(rollback.retryBefore?.legacyRows).toEqual(rollbackOriginal.legacyRows); |
| 418 | expect(rollback.recovered?.schemaVersion).toBe(2); |
| 419 | expect(rollback.recovered?.schemaRows).toEqual([{ id: 1, version: 2 }]); |
| 420 | expect(rollback.recovered?.legacyRows).toEqual(rollbackOriginal.legacyRows); |
| 421 | expect(rollback.recovered?.callbacks).toEqual([]); |
| 422 | expect(rollback.recovered?.tables).toContain("alchemy_alarm_callbacks"); |
| 423 | expect( |
| 424 | rollback.recovered?.schema.some( |
| 425 | (row) => row.name === "idx_alchemy_scheduled_events_run_at" && row.type === "index", |
| 426 | ), |
| 427 | ).toBe(true); |
| 428 | expect(rollback.recovered?.alarm).toBe(rollbackOriginal.alarm); |
| 429 | yield* stack.destroy(); |
| 430 | }), |
| 431 | // Live: up to ~75s of idle-gap waiting for the DO rollout (readyAfterRollout). |
| 432 | { tags: [...(dev ? ["local"] : ["live"])], timeout: 180_000 }, |
| 433 | ); |
| 434 | }, |
| 435 | ); |
| 436 | } |