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

main
ts 144 lines 4.84 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 Planetscale from "@alchemy.run/planetscale";
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(), Planetscale.providers()),
18 state: Alchemy.localState(),
19 });
20
21 const stack = beforeAll(deploy(Stack), { timeout: 1_800_000 });
22
23 afterAll.skipIf(!!process.env.NO_DESTROY)(destroy(Stack), {
24 timeout: 1_800_000,
25 });
26
27 test(
28 "worker exposes a URL, hyperdrive id, and planetscale identifiers",
29 Effect.gen(function* () {
30 const { url, databaseId, branchName, hyperdriveId } = yield* stack;
31
32 expect(url).toBeString();
33 expect(databaseId).toBeString();
34 expect(branchName).toBeString();
35 expect(hyperdriveId).toBeString();
36 }),
37 );
38
39 // Fresh `workers.dev` URLs transiently 404 (route still propagating) or 5xx
40 // (Hyperdrive/PlanetScale binding still settling). `Test.getWhenReady` fails on
41 // that cold-start window and retries until the worker answers; the first hit in
42 // each test rides it, subsequent requests run against the warmed worker.
43 const { getWhenReady } = Test;
44
45 test(
46 "worker exposes user CRUD through Drizzle / Hyperdrive / PlanetScale",
47 Effect.gen(function* () {
48 const { url } = yield* stack;
49 const baseUrl = url.replace(/\/+$/, "");
50
51 const initialResponse = yield* getWhenReady(baseUrl);
52 expect(initialResponse.status).toBe(200);
53
54 const initialBody = (yield* initialResponse.json) as unknown as {
55 users: User[];
56 };
57 expect(Array.isArray(initialBody.users)).toBe(true);
58
59 const createResponse = yield* HttpClient.execute(HttpClientRequest.post(baseUrl));
60 expect(createResponse.status).toBe(200);
61
62 const createBody = (yield* createResponse.json) as unknown as {
63 user: User[];
64 };
65 expect(createBody.user).toHaveLength(1);
66
67 const [createdUser] = createBody.user;
68 expect(createdUser.id).toBeNumber();
69 expect(createdUser.email).toBeString();
70 expect(createdUser.name).toBeString();
71 expect(createdUser.createdAt).toBeString();
72
73 const readResponse = yield* HttpClient.get(`${baseUrl}/${createdUser.id}`);
74 expect(readResponse.status).toBe(200);
75
76 const readBody = (yield* readResponse.json) as unknown as {
77 user: User & { posts: Post[] };
78 };
79 expect(readBody.user).toMatchObject({
80 id: createdUser.id,
81 email: createdUser.email,
82 name: createdUser.name,
83 posts: [],
84 });
85
86 const invalidReadResponse = yield* HttpClient.get(`${baseUrl}/not-a-user`);
87 expect(invalidReadResponse.status).toBe(400);
88 expect(yield* invalidReadResponse.json).toEqual({
89 error: "Invalid user ID",
90 });
91
92 const methodResponse = yield* HttpClient.execute(HttpClientRequest.patch(baseUrl));
93 expect(methodResponse.status).toBe(405);
94 expect(yield* methodResponse.json).toEqual({
95 error: "Method not allowed",
96 });
97
98 const deleteResponse = yield* HttpClient.execute(
99 HttpClientRequest.delete(`${baseUrl}/${createdUser.id}`),
100 );
101 expect(deleteResponse.status).toBe(200);
102
103 const deleteBody = (yield* deleteResponse.json) as unknown as {
104 user: User;
105 };
106 expect(deleteBody.user).toMatchObject({
107 id: createdUser.id,
108 email: createdUser.email,
109 name: createdUser.name,
110 });
111
112 const finalResponse = yield* HttpClient.get(baseUrl);
113 expect(finalResponse.status).toBe(200);
114 const finalBody = (yield* finalResponse.json) as unknown as {
115 users: User[];
116 };
117 expect(finalBody.users.some((user) => user.id === createdUser.id)).toBe(false);
118 }),
119 { timeout: 20_000 },
120 );
121
122 test(
123 "worker handles 100 sequential queries spaced 100-500ms apart",
124 Effect.gen(function* () {
125 const { url } = yield* stack;
126 const baseUrl = url.replace(/\/+$/, "");
127
128 yield* getWhenReady(baseUrl);
129
130 const queryOnce = Effect.gen(function* () {
131 const response = yield* HttpClient.get(baseUrl);
132 expect(response.status).toBe(200);
133 const body = (yield* response.json) as unknown as { users: User[] };
134 expect(Array.isArray(body.users)).toBe(true);
135 });
136
137 const jitter = Effect.sync(() => Math.floor(Math.random() * 401) + 100).pipe(
138 Effect.flatMap((ms) => Effect.sleep(Duration.millis(ms))),
139 );
140
141 yield* queryOnce.pipe(Effect.zip(jitter), Effect.repeat(Schedule.recurs(99)));
142 }),
143 { timeout: 120_000 },
144 );