@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 126 lines 4.56 KB
Raw
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 Data from "effect/Data";
5 import * as Effect from "effect/Effect";
6 import * as HttpClientRequest from "effect/http/HttpClientRequest";
7 import * as Schedule from "effect/Schedule";
8 import { requestWorker } from "../Utils/WorkerRequest.ts";
9 import WorkerV1 from "./fixtures/catch-up/v1.ts";
10 import WorkerLazy from "./fixtures/catch-up/v2-lazy.ts";
11
12 /** A route answered with something other than what the test waits for. */
13 class NotYet extends Data.TaggedError("NotYet")<{
14 readonly status: number;
15 readonly body: string;
16 }> {}
17
18 /** Call a route on a fresh connection, so the request reaches the latest deployment. */
19 const call = (url: string, method: "GET" | "POST", path: string) =>
20 requestWorker(
21 (method === "GET" ? HttpClientRequest.get : HttpClientRequest.post)(`${url}${path}`).pipe(
22 HttpClientRequest.setHeaders({ connection: "close", "cache-control": "no-cache" }),
23 ),
24 ).pipe(
25 Effect.retry({
26 while: (error) => error._tag === "HttpClientError",
27 schedule: Schedule.spaced("1 second"),
28 times: 5,
29 }),
30 Effect.flatMap((res) =>
31 res.text.pipe(
32 Effect.flatMap((body) =>
33 res.status === 200
34 ? Effect.succeed(body)
35 : Effect.fail(new NotYet({ status: res.status, body })),
36 ),
37 ),
38 ),
39 );
40
41 /** Wait until the Worker serves `version`: a redeploy takes a few seconds to roll out. */
42 const serving = (url: string, version: string) =>
43 call(url, "GET", "/version").pipe(
44 Effect.filterOrFail(
45 (body) => body === version,
46 (body) => new NotYet({ status: 200, body }),
47 ),
48 Effect.retry({ schedule: Schedule.spaced("2 seconds"), times: 90 }),
49 );
50
51 const deposit = (url: string, account: string, amount: number) =>
52 call(url, "POST", `/deposit/${account}/${amount}`).pipe(
53 Effect.retry({ schedule: Schedule.spaced("1 second"), times: 10 }),
54 );
55
56 /**
57 * Read an account's deposits: a lazy key answers its first read with its whole
58 * history. Only a host still on the code from before the deploy (no such route)
59 * is asked again.
60 */
61 const deposits = (url: string, account: string) =>
62 call(url, "GET", `/deposits/${account}`).pipe(
63 Effect.retry({
64 while: (e) => e._tag === "NotYet" && e.status === 404 && e.body === "Not Found",
65 schedule: Schedule.spaced("2 seconds"),
66 times: 30,
67 }),
68 Effect.map((body) => (JSON.parse(body) as { amounts: ReadonlyArray<number> } | null)?.amounts),
69 );
70
71 for (const dev of [true, false]) {
72 describe(dev ? "local lazy views" : "live lazy views", () => {
73 const { test } = Test.make({ providers: Cloudflare.providers(), dev });
74
75 test.provider(
76 `${dev ? "local" : "live"}: a lazy view added later fills each key when first read`,
77 (stack) =>
78 Effect.gen(function* () {
79 yield* stack.destroy();
80 const { worker } = yield* stack.deploy(
81 Effect.gen(function* () {
82 return { worker: yield* WorkerV1 };
83 }),
84 );
85 const url = worker.url!.replace(/\/+$/, "");
86 yield* serving(url, "v1");
87 yield* deposit(url, "a-1", 10);
88 yield* deposit(url, "a-1", 20);
89 yield* deposit(url, "a-2", 5);
90
91 // Adding a lazy view starts no backfill: the deploy has nothing to wait for.
92 const plan = yield* stack.plan(
93 Effect.gen(function* () {
94 return { worker: yield* WorkerLazy };
95 }),
96 );
97 expect(plan.resources["Ledger.DomainBackfillRun"]).toBeUndefined();
98 yield* stack.deploy(
99 Effect.gen(function* () {
100 return { worker: yield* WorkerLazy };
101 }),
102 );
103 yield* serving(url, "v2-lazy");
104
105 // The first read of each key reads its account's history.
106 expect(yield* deposits(url, "a-1")).toEqual([10, 20]);
107 expect(yield* deposits(url, "a-2")).toEqual([5]);
108 expect(JSON.parse(yield* call(url, "GET", "/history"))).toEqual({ complete: true });
109
110 // After that, new deposits arrive live.
111 yield* deposit(url, "a-1", 30);
112 const after = yield* deposits(url, "a-1").pipe(
113 Effect.repeat({
114 schedule: Schedule.spaced("1 second"),
115 until: (amounts) => amounts?.length === 3,
116 times: 30,
117 }),
118 );
119 expect(after).toEqual([10, 20, 30]);
120
121 yield* stack.destroy();
122 }),
123 { timeout: 600_000 },
124 );
125 });
126 }