@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.76 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 { inMemoryState } from "alchemy/State";
5 import * as Clock from "effect/Clock";
6 import * as Data from "effect/Data";
7 import * as Effect from "effect/Effect";
8 import * as HttpClientRequest from "effect/http/HttpClientRequest";
9 import * as Schedule from "effect/Schedule";
10 import { requestWorker } from "../Utils/WorkerRequest.ts";
11 import makeStack from "./fixtures/batches-stack.ts";
12
13 /** A route answered with something other than 200. */
14 class BatchRequestFailed extends Data.TaggedError("BatchRequestFailed")<{
15 readonly status: number;
16 }> {}
17
18 /** Call a route; right after a deploy, retry until the Worker serves it. */
19 const call = (request: HttpClientRequest.HttpClientRequest) =>
20 requestWorker(request.pipe(HttpClientRequest.setHeader("connection", "close"))).pipe(
21 Effect.filterOrFail(
22 (res) => res.status === 200,
23 (res) => new BatchRequestFailed({ status: res.status }),
24 ),
25 Effect.flatMap((res) => res.text),
26 Effect.retry({ schedule: Schedule.spaced("1 second"), times: 10 }),
27 );
28
29 describe.concurrent.each([
30 { dev: true, stage: `${Test.defaultStage()}-domain-batches-local` },
31 { dev: false, stage: `${Test.defaultStage()}-domain-batches-live` },
32 ] as const)("batched projections on Durable Objects (dev: $dev)", ({ dev, stage }) => {
33 const state = dev ? inMemoryState() : Cloudflare.state();
34 const Stack = makeStack(state);
35 const { test, beforeAll, afterAll, deploy, destroy } = Test.make({
36 providers: Cloudflare.providers(),
37 state,
38 dev,
39 stage,
40 });
41
42 const stack = beforeAll(
43 Effect.gen(function* () {
44 yield* destroy(Stack);
45 return yield* deploy(Stack);
46 }),
47 { timeout: 240_000 },
48 );
49 afterAll.skipIf(!!process.env.NO_DESTROY)(destroy(Stack), { timeout: 60_000 });
50
51 /** A fresh group's routes, so a retried test never reads an earlier attempt's pongs. */
52 const group = Effect.gen(function* () {
53 const { url } = yield* stack;
54 const base = url.replace(/\/+$/, "");
55 const group = yield* Effect.sync(() => crypto.randomUUID());
56 return {
57 ping: (id: string, slow = false) =>
58 call(HttpClientRequest.post(`${base}/ping/${group}/${id}${slow ? "?slow=true" : ""}`)),
59 pongs: call(HttpClientRequest.get(`${base}/pongs/${group}`)).pipe(
60 Effect.map((body) => JSON.parse(body) as string[]),
61 ),
62 };
63 });
64
65 test(
66 "a short batch runs once its wait is up",
67 Effect.gen(function* () {
68 const { ping, pongs } = yield* group;
69 const started = yield* Clock.currentTimeMillis;
70 yield* ping("only");
71 const answered = yield* pongs.pipe(
72 Effect.repeat({
73 schedule: Schedule.spaced("500 millis"),
74 until: (entries) => entries.length > 0,
75 times: 80,
76 }),
77 );
78 expect(answered).toEqual(["only"]);
79 // A new key's first ping arrives through backfill, from inside one of
80 // its callbacks, after a 5-second poll; then the batch waits 5 seconds:
81 // about 10. A wake-up lost with that callback's invocation leaves it to
82 // the backstop, which inherits the callback's 30-second backoff: about 35.
83 expect((yield* Clock.currentTimeMillis) - started).toBeLessThan(20_000);
84 }),
85 { timeout: 120_000 },
86 );
87
88 test(
89 "a batch that starts while another runs waits its batch wait, not a retry backoff",
90 Effect.gen(function* () {
91 const { ping, pongs } = yield* group;
92 // A new key's first ping arrives through backfill; once it's answered,
93 // the next ones arrive live.
94 yield* ping("warm");
95 yield* pongs.pipe(
96 Effect.repeat({
97 schedule: Schedule.spaced("500 millis"),
98 until: (entries) => entries.length > 0,
99 times: 80,
100 }),
101 );
102
103 const started = yield* Clock.currentTimeMillis;
104 // The slow ping's batch waits 5 seconds, then the drain's own callback
105 // runs it for 12.
106 yield* ping("slow", true);
107 // Halfway through that run, a second ping arrives. The drain finds it
108 // when the slow run ends, younger than the batch wait, and waits for it
109 // from inside its own callback.
110 yield* Effect.sleep("14 seconds");
111 yield* ping("late");
112 const answered = yield* pongs.pipe(
113 Effect.repeat({
114 schedule: Schedule.spaced("1 second"),
115 until: (entries) => entries.includes("late"),
116 times: 60,
117 }),
118 );
119 expect(answered).toEqual(["warm", "slow", "late"]);
120 // On time: answered about 19 seconds in. Waiting out the drain's 30-second
121 // retry backoff instead: about 47.
122 expect((yield* Clock.currentTimeMillis) - started).toBeLessThan(32_000);
123 }),
124 { timeout: 150_000 },
125 );
126 });