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

main
ts 137 lines 5.07 KB
Raw
1 import * as GCP from "@alchemy.run/gcp";
2 import { GcpEnvironment } from "@alchemy.run/gcp/Environment";
3 import { expect } from "@alchemy.run/test";
4 import * as Test from "@alchemy.run/test/Alchemy";
5 import * as composer from "@distilled.cloud/gcp/composer_v1";
6 import * as Effect from "effect/Effect";
7 import { MinimumLogLevel } from "effect/References";
8 import * as Schedule from "effect/Schedule";
9 import { CAPACITY_REGION } from "../zones.ts";
10 import { defaultComputeServiceAccount } from "./serviceAccount.ts";
11
12 const { test } = Test.make({ providers: GCP.providers() });
13
14 const logLevel = Effect.provideService(MinimumLogLevel, process.env.DEBUG ? "Debug" : "Info");
15
16 // Composer environments take 20-45 minutes to provision.
17 const runLifecycle = !!process.env.GCP_TEST_SLOW && !process.env.FAST;
18
19 const missingParentOf = (project: string) =>
20 `projects/${project}/locations/${CAPACITY_REGION}/environments/alchemy-composer-missing`;
21
22 const waitUntilGone = (name: string) =>
23 composer.getProjectsLocationsEnvironmentsUserWorkloadsSecrets({ name }).pipe(
24 Effect.as("found" as const),
25 Effect.catchTag("NotFound", () => Effect.succeed("gone" as const)),
26 Effect.repeat({
27 schedule: Schedule.spaced("1 second"),
28 until: (status) => status === "gone",
29 times: 10,
30 }),
31 );
32
33 test.provider(
34 "getProjectsLocationsEnvironmentsUserWorkloadsSecrets on a missing secret fails with NotFound",
35 (stack) =>
36 Effect.gen(function* () {
37 const { project } = yield* GcpEnvironment.current;
38 const missingParent = missingParentOf(project);
39 yield* stack.destroy();
40
41 const error = yield* Effect.flip(
42 composer.getProjectsLocationsEnvironmentsUserWorkloadsSecrets({
43 name: `${missingParent}/userWorkloadsSecrets/alchemy-missing`,
44 }),
45 );
46 expect(error._tag).toEqual("NotFound");
47
48 const created = yield* Effect.flip(
49 composer.createProjectsLocationsEnvironmentsUserWorkloadsSecrets({
50 parent: missingParent,
51 body: {
52 name: `${missingParent}/userWorkloadsSecrets/alchemy-missing`,
53 data: { password: btoa("s3cret") },
54 },
55 }),
56 );
57 expect(created._tag).toEqual("NotFound");
58
59 yield* stack.destroy();
60 }).pipe(logLevel),
61 { tags: ["provider:gcp", "provider:gcp:composer", "live"], timeout: 90_000 },
62 );
63
64 test.provider.skipIf(!runLifecycle)(
65 "create, update, and delete a user workloads secret",
66 (stack) =>
67 Effect.gen(function* () {
68 const serviceAccount = yield* defaultComputeServiceAccount;
69 yield* stack.destroy();
70
71 const created = yield* stack.deploy(
72 Effect.gen(function* () {
73 const airflow = yield* GCP.Composer.Environment("Airflow", {
74 location: CAPACITY_REGION,
75 config: {
76 environmentSize: "ENVIRONMENT_SIZE_SMALL",
77 nodeConfig: { serviceAccount },
78 softwareConfig: { imageVersion: "composer-3-airflow-2" },
79 },
80 });
81 const secret = yield* GCP.Composer.EnvironmentsUserWorkloadsSecret("TaskSecret", {
82 environmentName: airflow.name,
83 data: { password: btoa("s3cret") },
84 });
85 return { airflow, secret };
86 }),
87 );
88
89 expect(created.secret.name).toContain("/userWorkloadsSecrets/");
90 expect(created.secret.environmentName).toEqual(created.airflow.name);
91 expect(created.secret.data["alchemy-id"]).toBeUndefined();
92
93 const fetched = yield* composer.getProjectsLocationsEnvironmentsUserWorkloadsSecrets({
94 name: created.secret.name,
95 });
96 expect(fetched.name).toEqual(created.secret.name);
97 expect(Object.keys(fetched.data ?? {}).sort()).toEqual(["password"]);
98
99 const updated = yield* stack.deploy(
100 Effect.gen(function* () {
101 const airflow = yield* GCP.Composer.Environment("Airflow", {
102 environmentId: created.airflow.environmentId,
103 location: CAPACITY_REGION,
104 config: {
105 environmentSize: "ENVIRONMENT_SIZE_SMALL",
106 nodeConfig: { serviceAccount },
107 softwareConfig: { imageVersion: "composer-3-airflow-2" },
108 },
109 });
110 const secret = yield* GCP.Composer.EnvironmentsUserWorkloadsSecret("TaskSecret", {
111 environmentName: airflow.name,
112 secretId: created.secret.secretId,
113 data: { password: btoa("rotated"), token: btoa("abc123") },
114 });
115 return { airflow, secret };
116 }),
117 );
118
119 expect(updated.secret.name).toEqual(created.secret.name);
120
121 const refetched = yield* composer.getProjectsLocationsEnvironmentsUserWorkloadsSecrets({
122 name: created.secret.name,
123 });
124 expect(Object.keys(refetched.data ?? {}).sort()).toEqual(["password", "token"]);
125
126 yield* stack.destroy();
127
128 const gone = yield* waitUntilGone(created.secret.name);
129 expect(gone).toEqual("gone");
130 }).pipe(logLevel),
131 // Create (~45 min) + update + delete; a timed-out lifecycle is not retried.
132 {
133 tags: ["provider:gcp", "provider:gcp:composer", "live"],
134 timeout: 5_400_000,
135 retry: 0,
136 },
137 );