@devries-cameron20 / t3code Mirror · read-only
Fork 0

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

main
ts 127 lines 4.81 KB
Raw
1 import { expect } from "@alchemy.run/test";
2 import * as workers from "@distilled.cloud/cloudflare/workers";
3 import * as Data from "effect/Data";
4 import * as Effect from "effect/Effect";
5 import * as Schedule from "effect/Schedule";
6
7 /**
8 * Test helpers for asserting against Cloudflare Worker state via the
9 * official workers SDK. These wrap the common "exists / get tags / wait
10 * for delete" patterns used across `Worker.test.ts` and the website
11 * tests so callers don't reimplement the retry plumbing each time.
12 */
13
14 class WorkerStillExists extends Data.TaggedError("WorkerStillExists") {}
15
16 /**
17 * Poll Cloudflare's `getScriptSubdomain` until it reports `expected`,
18 * then assert. Cloudflare's subdomain toggle is eventually consistent
19 * with respect to a freshly-completed `putScript` /
20 * `createScriptSubdomain` call, so a same-tick read may still return
21 * the previous value for a second or two. Retries indefinitely with a
22 * fixed cadence; the surrounding test's own timeout bounds the wait.
23 */
24 export const expectWorkersDevSubdomain = Effect.fn(function* (
25 workerName: string,
26 accountId: string,
27 expected: boolean,
28 ) {
29 const final = yield* workers.getScriptSubdomain({ accountId, scriptName: workerName }).pipe(
30 Effect.flatMap((s) =>
31 s.enabled === expected
32 ? Effect.succeed(s)
33 : Effect.fail(`subdomain not yet ${expected ? "enabled" : "disabled"}`),
34 ),
35 Effect.tapError(Effect.logInfo),
36 Effect.retry({ schedule: Schedule.spaced("500 millis") }),
37 );
38 expect(final.enabled).toBe(expected);
39 });
40
41 /**
42 * Poll Cloudflare's `getScriptSubdomain` until both `enabled` and
43 * `previewsEnabled` match the expected values, then assert. Like
44 * `expectWorkersDevSubdomain`, the subdomain toggle is eventually
45 * consistent with respect to a freshly-completed `putScript` /
46 * `createScriptSubdomain` call, so a same-tick read may still return the
47 * previous value for a second or two. Retries indefinitely with a fixed
48 * cadence; the surrounding test's own timeout bounds the wait.
49 */
50 export const expectWorkersDevPreviews = Effect.fn(function* (
51 workerName: string,
52 accountId: string,
53 expected: { enabled: boolean; previewsEnabled: boolean },
54 ) {
55 const final = yield* workers.getScriptSubdomain({ accountId, scriptName: workerName }).pipe(
56 Effect.flatMap((s) =>
57 s.enabled === expected.enabled && s.previewsEnabled === expected.previewsEnabled
58 ? Effect.succeed(s)
59 : Effect.fail(
60 `subdomain not yet { enabled: ${expected.enabled}, previewsEnabled: ${expected.previewsEnabled} }`,
61 ),
62 ),
63 Effect.tapError(Effect.logInfo),
64 Effect.retry({ schedule: Schedule.spaced("500 millis") }),
65 );
66 expect(final).toEqual(expected);
67 });
68
69 /**
70 * Look up a worker by name. Returns `undefined` if no script with that
71 * name exists in the account.
72 */
73 export const findWorker = Effect.fn(function* (workerName: string, accountId: string) {
74 const matches = yield* workers.searchScript({
75 accountId,
76 name: workerName,
77 });
78 return matches.find((worker) => worker.scriptName === workerName);
79 });
80
81 /**
82 * Read the tags currently attached to a worker's live script settings.
83 * Useful for asserting `alchemy:stack:*` / `alchemy:stage:*` ownership
84 * tags without round-tripping through `searchScript`.
85 */
86 export const getWorkerTags = Effect.fn(function* (workerName: string, accountId: string) {
87 const settings = yield* workers.getScriptScriptAndVersionSetting({
88 accountId,
89 scriptName: workerName,
90 });
91 return settings.tags ?? [];
92 });
93
94 /**
95 * Asserts that a worker exists on Cloudflare. Use as a deploy
96 * checkpoint that doesn't take a propagation dependency on the
97 * workers.dev subdomain.
98 */
99 export const expectWorkerExists = Effect.fn(function* (workerName: string, accountId: string) {
100 const settings = yield* workers.getScriptScriptAndVersionSetting({
101 accountId,
102 scriptName: workerName,
103 });
104 expect(settings).toBeDefined();
105 });
106
107 /**
108 * Block until Cloudflare reports the worker is gone. Uses exponential
109 * backoff; safe to call after `stack.destroy()` to ensure subsequent
110 * tests in the same file don't observe the about-to-be-deleted worker.
111 */
112 export const waitForWorkerToBeDeleted = Effect.fn(function* (
113 workerName: string,
114 accountId: string,
115 ) {
116 yield* workers.getScript({ accountId, scriptName: workerName }).pipe(
117 Effect.flatMap(() => Effect.fail(new WorkerStillExists())),
118 Effect.retry({
119 while: (e): e is WorkerStillExists => e instanceof WorkerStillExists,
120 schedule: Schedule.max([Schedule.exponential(100), Schedule.recurs(20)]),
121 }),
122 // Deletion propagates in stages: getScript can briefly report the
123 // worker as existing-but-empty ("has no versions") before the 10007
124 // not-found lands. Both mean the worker is gone for our purposes.
125 Effect.catchTag(["WorkerNotFound", "WorkerHasNoVersions"], () => Effect.void),
126 );
127 });