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

main
ts 389 lines 15 KB
Raw
1 import * as Prisma from "@alchemy.run/prisma";
2 import { expect } from "@alchemy.run/test";
3 import * as Test from "@alchemy.run/test/Alchemy";
4 import { getService, updateService } from "@distilled.cloud/prisma/management";
5 import { adopt, OwnedBySomeoneElse } from "alchemy/AdoptPolicy";
6 import * as Provider from "alchemy/Provider";
7 import * as Effect from "effect/Effect";
8 import {
9 expectGone,
10 expectProjectGone,
11 failureOf,
12 forgetState,
13 markCreating,
14 patchStateAttr,
15 } from "./fixtures/Live.ts";
16
17 const live = Test.make({ providers: Prisma.providers() });
18
19 const liveTags = [
20 "provider:prisma",
21 "provider:prisma:app",
22 "provider:prisma:branch",
23 "provider:prisma:project",
24 "live",
25 ];
26
27 const observeApp = (appId: string) =>
28 getService({ serviceId: appId }).pipe(Effect.map((response) => response.data));
29
30 const expectAppGone = (appId: string) =>
31 expectGone(
32 getService({ serviceId: appId }).pipe(
33 Effect.as(false),
34 Effect.catchTag("NotFound", () => Effect.succeed(true)),
35 ),
36 );
37
38 const appStack = (props: { displayName?: string; logicalId?: string } = {}) =>
39 Effect.gen(function* () {
40 const project = yield* Prisma.Project("Project", { createDatabase: false });
41 const app = yield* Prisma.App("Web", { project, ...props });
42 return { project, app };
43 });
44
45 live.test.provider(
46 "creates an App under its fqn logical ID and converges name and logical ID in place",
47 Effect.fn(function* (stack: Test.ScratchStack) {
48 yield* stack.destroy();
49
50 const initial = yield* stack.deploy(appStack());
51 expect(initial.app.logicalId).toBe("Web");
52 const created = yield* observeApp(initial.app.appId);
53 expect(created.projectId).toBe(initial.project.projectId);
54 expect(created.name).toBe(initial.app.name);
55 expect(created.logicalId).toBe("Web");
56
57 const renamed = yield* stack.deploy(appStack({ displayName: "renamed-web" }));
58 expect(renamed.app.appId).toBe(initial.app.appId);
59 expect((yield* observeApp(initial.app.appId)).name).toBe("renamed-web");
60
61 const overridden = yield* stack.deploy(
62 appStack({ displayName: "renamed-web", logicalId: "web-override" }),
63 );
64 expect(overridden.app.appId).toBe(initial.app.appId);
65 expect(overridden.app.logicalId).toBe("web-override");
66 expect((yield* observeApp(initial.app.appId)).logicalId).toBe("web-override");
67
68 // Removing the override returns to the fqn.
69 const reverted = yield* stack.deploy(appStack({ displayName: "renamed-web" }));
70 expect(reverted.app.appId).toBe(initial.app.appId);
71 expect((yield* observeApp(initial.app.appId)).logicalId).toBe("Web");
72
73 const repeated = yield* stack.deploy(appStack({ displayName: "renamed-web" }));
74 expect(repeated.app.appId).toBe(initial.app.appId);
75
76 // Nuke enumerates Apps through the provider's list.
77 const listed = yield* (yield* Provider.findProvider(Prisma.App)).list!();
78 expect(listed.map((app) => app.appId)).toContain(initial.app.appId);
79
80 yield* stack.destroy();
81 yield* expectAppGone(initial.app.appId);
82 yield* expectProjectGone(initial.project.projectId);
83 }),
84 { tags: liveTags, timeout: 180_000 },
85 );
86
87 live.test.provider(
88 "after lost state, adoption finds the App by its logical ID despite a Console rename",
89 Effect.fn(function* (stack: Test.ScratchStack) {
90 yield* stack.destroy();
91
92 const initial = yield* stack.deploy(appStack());
93 yield* updateService({ serviceId: initial.app.appId, displayName: "renamed-in-console" });
94 // Lost state also loses the instance ID, so nothing proves the App is ours.
95 yield* forgetState(stack, "Web");
96
97 const refused = yield* failureOf(stack.deploy(appStack()));
98 expect(refused.errors.some((error) => error instanceof OwnedBySomeoneElse)).toBe(true);
99 expect((yield* observeApp(initial.app.appId)).name).toBe("renamed-in-console");
100
101 const adopted = yield* stack.deploy(
102 Effect.gen(function* () {
103 const project = yield* Prisma.Project("Project", { createDatabase: false });
104 const app = yield* Prisma.App("Web", { project }).pipe(adopt(true));
105 return { project, app };
106 }),
107 );
108 expect(adopted.app.appId).toBe(initial.app.appId);
109 const observed = yield* observeApp(initial.app.appId);
110 expect(observed.name).toBe(adopted.app.name);
111 expect(observed.logicalId).toBe("Web");
112
113 yield* stack.destroy();
114 yield* expectAppGone(initial.app.appId);
115 yield* expectProjectGone(initial.project.projectId);
116 }),
117 { tags: liveTags, timeout: 180_000 },
118 );
119
120 live.test.provider(
121 "recovers an interrupted App create as owned",
122 Effect.fn(function* (stack: Test.ScratchStack) {
123 yield* stack.destroy();
124
125 const initial = yield* stack.deploy(appStack());
126 // The App exists, but the create never committed its attributes.
127 yield* markCreating(stack, "Web");
128
129 const recovered = yield* stack.deploy(appStack());
130 expect(recovered.app.appId).toBe(initial.app.appId);
131 expect((yield* observeApp(initial.app.appId)).logicalId).toBe("Web");
132
133 yield* stack.destroy();
134 yield* expectAppGone(initial.app.appId);
135 yield* expectProjectGone(initial.project.projectId);
136 }),
137 { tags: liveTags, timeout: 180_000 },
138 );
139
140 live.test.provider(
141 "a later declaration reusing a held logical ID does not take over the App",
142 Effect.fn(function* (stack: Test.ScratchStack) {
143 yield* stack.destroy();
144
145 const resources = (withSecond: boolean) =>
146 Effect.gen(function* () {
147 const project = yield* Prisma.Project("Project", { createDatabase: false });
148 const first = yield* Prisma.App("First", { project, logicalId: "shared" });
149 const second = withSecond
150 ? yield* Prisma.App("Second", { project, logicalId: "shared" })
151 : undefined;
152 return { project, first, second };
153 });
154
155 const initial = yield* stack.deploy(resources(false));
156 const refused = yield* failureOf(stack.deploy(resources(true)));
157 expect(refused.errors.some((error) => error instanceof OwnedBySomeoneElse)).toBe(true);
158
159 // First's App survives a deploy that drops the failed declaration.
160 yield* stack.deploy(resources(false));
161 expect((yield* observeApp(initial.first.appId)).logicalId).toBe("shared");
162
163 yield* stack.destroy();
164 yield* expectAppGone(initial.first.appId);
165 yield* expectProjectGone(initial.project.projectId);
166 }),
167 { tags: liveTags, timeout: 180_000 },
168 );
169
170 live.test.provider(
171 "sets the logical ID on an App deployed before logical IDs existed",
172 Effect.fn(function* (stack: Test.ScratchStack) {
173 yield* stack.destroy();
174
175 const initial = yield* stack.deploy(appStack({ displayName: "legacy-web" }));
176 // What an earlier provider version left behind: no logical ID in the
177 // cloud or in the persisted attributes.
178 yield* updateService({ serviceId: initial.app.appId, logicalId: null });
179 yield* patchStateAttr(stack, "Web", { logicalId: null });
180 expect((yield* observeApp(initial.app.appId)).logicalId).toBeNull();
181
182 const stamped = yield* stack.deploy(appStack({ displayName: "legacy-web" }));
183 expect(stamped.app.appId).toBe(initial.app.appId);
184 expect(stamped.app.logicalId).toBe("Web");
185 expect((yield* observeApp(initial.app.appId)).logicalId).toBe("Web");
186
187 yield* stack.destroy();
188 yield* expectAppGone(initial.app.appId);
189 yield* expectProjectGone(initial.project.projectId);
190 }),
191 { tags: liveTags, timeout: 180_000 },
192 );
193
194 live.test.provider(
195 "requires adoption for an App without a logical ID after lost state, then sets it",
196 Effect.fn(function* (stack: Test.ScratchStack) {
197 yield* stack.destroy();
198
199 const initial = yield* stack.deploy(appStack({ displayName: "legacy-web" }));
200 yield* updateService({ serviceId: initial.app.appId, logicalId: null });
201 yield* forgetState(stack, "Web");
202
203 // Found only by display name, so it is not provably ours.
204 const refused = yield* failureOf(stack.deploy(appStack({ displayName: "legacy-web" })));
205 expect(refused.errors.some((error) => error instanceof OwnedBySomeoneElse)).toBe(true);
206
207 const adopted = yield* stack.deploy(
208 Effect.gen(function* () {
209 const project = yield* Prisma.Project("Project", { createDatabase: false });
210 const app = yield* Prisma.App("Web", { project, displayName: "legacy-web" }).pipe(
211 adopt(true),
212 );
213 return { project, app };
214 }),
215 );
216 expect(adopted.app.appId).toBe(initial.app.appId);
217 expect((yield* observeApp(initial.app.appId)).logicalId).toBe("Web");
218
219 yield* stack.destroy();
220 yield* expectAppGone(initial.app.appId);
221 yield* expectProjectGone(initial.project.projectId);
222 }),
223 { tags: liveTags, timeout: 180_000 },
224 );
225
226 live.test.provider(
227 "rejects a logical ID that another App on the branch holds",
228 Effect.fn(function* (stack: Test.ScratchStack) {
229 yield* stack.destroy();
230
231 const resources = (secondLogicalId: string) =>
232 Effect.gen(function* () {
233 const project = yield* Prisma.Project("Project", { createDatabase: false });
234 const first = yield* Prisma.App("First", { project, logicalId: "shared" });
235 const second = yield* Prisma.App("Second", { project, logicalId: secondLogicalId });
236 return { project, first, second };
237 });
238
239 const initial = yield* stack.deploy(resources("second"));
240 expect(initial.second.appId).not.toBe(initial.first.appId);
241
242 const failure = yield* failureOf(stack.deploy(resources("shared")));
243 expect(failure.text).toContain("logical ID 'shared'");
244 expect((yield* observeApp(initial.first.appId)).logicalId).toBe("shared");
245
246 yield* stack.destroy();
247 yield* expectAppGone(initial.first.appId);
248 yield* expectAppGone(initial.second.appId);
249 yield* expectProjectGone(initial.project.projectId);
250 }),
251 { tags: liveTags, timeout: 180_000 },
252 );
253
254 live.test.provider(
255 "attaches to a branch by git name and inherits the project region",
256 Effect.fn(function* (stack: Test.ScratchStack) {
257 yield* stack.destroy();
258
259 const deployed = yield* stack.deploy(
260 Effect.gen(function* () {
261 const project = yield* Prisma.Project("Project", {
262 createDatabase: false,
263 region: "eu-west-3",
264 });
265 const branch = yield* Prisma.Branch("Feature", { project, gitName: "feature/app" });
266 const app = yield* Prisma.App("Web", { project, branchGitName: branch.gitName });
267 return { project, branch, app };
268 }),
269 );
270 expect(deployed.app.branchId).toBe(deployed.branch.branchId);
271 expect(deployed.app.regionId).toBe("eu-west-3");
272 const observed = yield* observeApp(deployed.app.appId);
273 expect(observed.branchId).toBe(deployed.branch.branchId);
274 expect(observed.region.id).toBe("eu-west-3");
275
276 yield* stack.destroy();
277 yield* expectAppGone(deployed.app.appId);
278 yield* expectProjectGone(deployed.project.projectId);
279 }),
280 { tags: liveTags, timeout: 180_000 },
281 );
282
283 live.test.provider(
284 "refuses a region change and replaces the App when its project changes",
285 Effect.fn(function* (stack: Test.ScratchStack) {
286 yield* stack.destroy();
287
288 // Both projects exist before the move, so the new project ID is known at plan time.
289 const resources = (target: "first" | "second", regionId?: "us-east-1" | "eu-west-3") =>
290 Effect.gen(function* () {
291 const first = yield* Prisma.Project("First", { createDatabase: false });
292 const second = yield* Prisma.Project("Second", { createDatabase: false });
293 const app = yield* Prisma.App("Web", {
294 project: target === "first" ? first : second,
295 ...(regionId === undefined ? {} : { regionId }),
296 });
297 return { first, second, app };
298 });
299
300 const initial = yield* stack.deploy(resources("first"));
301 expect(initial.app.regionId).toBe("us-east-1");
302
303 const moved = yield* failureOf(stack.deploy(resources("first", "eu-west-3")));
304 expect(moved.text).toContain("cannot atomically move an App");
305 expect((yield* observeApp(initial.app.appId)).region.id).toBe("us-east-1");
306
307 const replaced = yield* stack.deploy(resources("second"));
308 expect(replaced.app.appId).not.toBe(initial.app.appId);
309 expect((yield* observeApp(replaced.app.appId)).projectId).toBe(initial.second.projectId);
310 yield* expectAppGone(initial.app.appId);
311
312 yield* stack.destroy();
313 yield* expectAppGone(replaced.app.appId);
314 yield* expectProjectGone(initial.first.projectId);
315 yield* expectProjectGone(initial.second.projectId);
316 }),
317 { tags: liveTags, timeout: 180_000 },
318 );
319
320 live.test.provider(
321 "follows a newly promoted default branch",
322 Effect.fn(function* (stack: Test.ScratchStack) {
323 yield* stack.destroy();
324
325 const resources = (promote: boolean) =>
326 Effect.gen(function* () {
327 const project = yield* Prisma.Project("Project", { createDatabase: false });
328 const next = promote
329 ? yield* Prisma.Branch("Next", { project, gitName: "next", isDefault: true })
330 : undefined;
331 const app = yield* Prisma.App("Web", { project });
332 return { project, next, app };
333 });
334
335 const initial = yield* stack.deploy(resources(false));
336 // The promotion lands first; the next deploy sees the new default.
337 yield* stack.deploy(resources(true));
338 const followed = yield* stack.deploy(resources(true));
339 expect(followed.app.appId).toBe(initial.app.appId);
340 expect(followed.app.branchId).toBe(followed.next!.branchId);
341 expect((yield* observeApp(initial.app.appId)).branchId).toBe(followed.next!.branchId);
342
343 yield* stack.destroy();
344 yield* expectAppGone(initial.app.appId);
345 yield* expectProjectGone(initial.project.projectId);
346 }),
347 { tags: liveTags, timeout: 180_000 },
348 );
349
350 live.test.provider(
351 "repairs out-of-band drift on the next update and deletes despite it",
352 Effect.fn(function* (stack: Test.ScratchStack) {
353 yield* stack.destroy();
354
355 const resources = (logicalId?: string) =>
356 Effect.gen(function* () {
357 const project = yield* Prisma.Project("Project", { createDatabase: false });
358 const feature = yield* Prisma.Branch("Feature", { project, gitName: "feature/drift" });
359 const app = yield* Prisma.App("Web", {
360 project,
361 displayName: "web",
362 ...(logicalId === undefined ? {} : { logicalId }),
363 });
364 return { project, feature, app };
365 });
366
367 const initial = yield* stack.deploy(resources());
368 const defaultBranchId = initial.app.branchId;
369 yield* updateService({
370 serviceId: initial.app.appId,
371 displayName: "drifted",
372 branchId: initial.feature.branchId,
373 });
374
375 // Any update reconciles against observed state, not the persisted attributes.
376 const repaired = yield* stack.deploy(resources("web-repaired"));
377 expect(repaired.app.appId).toBe(initial.app.appId);
378 const observed = yield* observeApp(initial.app.appId);
379 expect(observed.name).toBe("web");
380 expect(observed.branchId).toBe(defaultBranchId);
381 expect(observed.logicalId).toBe("web-repaired");
382
383 yield* updateService({ serviceId: initial.app.appId, displayName: "drifted-again" });
384 yield* stack.destroy();
385 yield* expectAppGone(initial.app.appId);
386 yield* expectProjectGone(initial.project.projectId);
387 }),
388 { tags: liveTags, timeout: 180_000 },
389 );