The best way to control Claude Code, Codex and more from any computer or phone

main
ts 152 lines 5.42 KB
Raw
1 import { expect } from "bun:test";
2 import * as Cloudflare from "@alchemy.run/cloudflare";
3 import * as Drizzle from "@alchemy.run/drizzle";
4 import * as Neon from "@alchemy.run/neon";
5 import * as Test from "@alchemy.run/test/Bun";
6 import * as Alchemy from "alchemy";
7 import * as Duration from "effect/Duration";
8 import * as Effect from "effect/Effect";
9 import * as HttpClient from "effect/http/HttpClient";
10 import * as HttpClientRequest from "effect/http/HttpClientRequest";
11 import * as Layer from "effect/Layer";
12 import * as Schedule from "effect/Schedule";
13 import Stack from "../alchemy.run.ts";
14 import type { Post, User } from "../src/schema.ts";
15
16 const { test, beforeAll, afterAll, deploy, destroy } = Test.make({
17 providers: Layer.mergeAll(Cloudflare.providers(), Drizzle.providers(), Neon.providers()),
18 state: Alchemy.localState(),
19 });
20
21 const stack = beforeAll(deploy(Stack), { timeout: 240_000 });
22
23 afterAll.skipIf(!!process.env.NO_DESTROY)(destroy(Stack), {
24 timeout: 180_000,
25 });
26
27 // Fresh `workers.dev` URLs transiently 404 (route still propagating) or 5xx
28 // (Hyperdrive/Neon binding still settling). `Test.getWhenReady` fails on that
29 // cold-start window and retries until the worker answers — but one 200 does
30 // not mean the route has converged everywhere: for the first ~30s after
31 // "Enabling workers.dev subdomain" consecutive requests can interleave 200s
32 // with edge-generated HTML 404s. The worker itself only ever answers JSON
33 // (including its own 400/405/500), so guard the client on content-type: any
34 // HTML edge page is rejected and retried, while the worker's real statuses
35 // stay observable for the assertions below.
36 const { getWhenReady } = Test;
37 const jsonClient = Test.guardedFetchLayer("application/json", { times: 10 });
38
39 test(
40 "worker exposes a URL, hyperdrive id, and neon branch id",
41 Effect.gen(function* () {
42 const { url, branchId, hyperdriveId } = yield* stack;
43
44 expect(url).toBeString();
45 expect(branchId).toBeString();
46 expect(hyperdriveId).toBeString();
47 }),
48 );
49
50 test(
51 "worker exposes user CRUD through Drizzle / Hyperdrive / Neon",
52 Effect.gen(function* () {
53 const { url } = yield* stack;
54 const baseUrl = url.replace(/\/+$/, "");
55
56 const initialResponse = yield* getWhenReady(baseUrl);
57 expect(initialResponse.status).toBe(200);
58
59 const initialBody = (yield* initialResponse.json) as unknown as {
60 users: User[];
61 };
62 expect(Array.isArray(initialBody.users)).toBe(true);
63
64 const createResponse = yield* HttpClient.execute(HttpClientRequest.post(baseUrl));
65 expect(createResponse.status).toBe(200);
66
67 const createBody = (yield* createResponse.json) as unknown as {
68 user: User[];
69 };
70 expect(createBody.user).toHaveLength(1);
71
72 const [createdUser] = createBody.user;
73 expect(createdUser.id).toBeNumber();
74 expect(createdUser.email).toBeString();
75 expect(createdUser.name).toBeString();
76 expect(createdUser.createdAt).toBeString();
77
78 const readResponse = yield* HttpClient.get(`${baseUrl}/${createdUser.id}`);
79 expect(readResponse.status).toBe(200);
80
81 const readBody = (yield* readResponse.json) as unknown as {
82 user: User & { posts: Post[] };
83 };
84 expect(readBody.user).toMatchObject({
85 id: createdUser.id,
86 email: createdUser.email,
87 name: createdUser.name,
88 posts: [],
89 });
90
91 const invalidReadResponse = yield* HttpClient.get(`${baseUrl}/not-a-user`);
92 expect(invalidReadResponse.status).toBe(400);
93 expect(yield* invalidReadResponse.json).toEqual({
94 error: "Invalid user ID",
95 });
96
97 const methodResponse = yield* HttpClient.execute(HttpClientRequest.patch(baseUrl));
98 expect(methodResponse.status).toBe(405);
99 expect(yield* methodResponse.json).toEqual({
100 error: "Method not allowed",
101 });
102
103 const deleteResponse = yield* HttpClient.execute(
104 HttpClientRequest.delete(`${baseUrl}/${createdUser.id}`),
105 );
106 expect(deleteResponse.status).toBe(200);
107
108 const deleteBody = (yield* deleteResponse.json) as unknown as {
109 user: User;
110 };
111 expect(deleteBody.user).toMatchObject({
112 id: createdUser.id,
113 email: createdUser.email,
114 name: createdUser.name,
115 });
116
117 const finalResponse = yield* HttpClient.get(baseUrl);
118 expect(finalResponse.status).toBe(200);
119 const finalBody = (yield* finalResponse.json) as unknown as {
120 users: User[];
121 };
122 expect(finalBody.users.some((user) => user.id === createdUser.id)).toBe(false);
123 }).pipe(Effect.provide(jsonClient)),
124 // The cold-start `getWhenReady` window plus a full CRUD round-trip against a
125 // freshly-warmed Neon/Hyperdrive connection routinely exceeds 20s. Match the
126 // sequential-query case's budget.
127 { timeout: 120_000 },
128 );
129
130 test(
131 "worker handles 100 sequential queries spaced 100-500ms apart",
132 Effect.gen(function* () {
133 const { url } = yield* stack;
134 const baseUrl = url.replace(/\/+$/, "");
135
136 yield* getWhenReady(baseUrl);
137
138 const queryOnce = Effect.gen(function* () {
139 const response = yield* HttpClient.get(baseUrl);
140 expect(response.status).toBe(200);
141 const body = (yield* response.json) as unknown as { users: User[] };
142 expect(Array.isArray(body.users)).toBe(true);
143 });
144
145 const jitter = Effect.sync(() => Math.floor(Math.random() * 401) + 100).pipe(
146 Effect.flatMap((ms) => Effect.sleep(Duration.millis(ms))),
147 );
148
149 yield* queryOnce.pipe(Effect.zip(jitter), Effect.repeat(Schedule.recurs(99)));
150 }).pipe(Effect.provide(jsonClient)),
151 { timeout: 120_000 },
152 );