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

main
ts 173 lines 6.04 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 compute from "@distilled.cloud/gcp/compute_v1";
6 import * as Effect from "effect/Effect";
7 import { MinimumLogLevel } from "effect/References";
8 import * as Schedule from "effect/Schedule";
9
10 const { test } = Test.make({ providers: GCP.providers() });
11
12 const logLevel = Effect.provideService(MinimumLogLevel, process.env.DEBUG ? "Debug" : "Info");
13
14 const zone = "us-central1-a";
15 const replaceZone = "us-central1-b";
16
17 const waitUntilGone = (zoneName: string, instanceGroupManager: string) =>
18 GcpEnvironment.current.pipe(
19 Effect.flatMap(({ project }) =>
20 compute
21 .getInstanceGroupManagers({
22 project,
23 zone: zoneName,
24 instanceGroupManager,
25 })
26 .pipe(
27 Effect.as("found" as const),
28 Effect.catchTag("NotFound", () => Effect.succeed("gone" as const)),
29 Effect.repeat({
30 schedule: Schedule.spaced("1 second"),
31 until: (status) => status === "gone",
32 times: 15,
33 }),
34 ),
35 ),
36 );
37
38 const templateProps: GCP.Compute.InstanceTemplateProps = {
39 machineType: "e2-micro",
40 disks: [
41 {
42 boot: true,
43 autoDelete: true,
44 sourceImage: "projects/debian-cloud/global/images/family/debian-12",
45 diskSizeGb: 10,
46 },
47 ],
48 networkInterfaces: [{ network: "global/networks/default" }],
49 };
50
51 test.provider(
52 "create, update, replace, and delete an instance group manager",
53 (stack) =>
54 Effect.gen(function* () {
55 const { project } = yield* GcpEnvironment.current;
56 yield* stack.destroy();
57
58 const created = yield* stack.deploy(
59 Effect.gen(function* () {
60 const template = yield* GCP.Compute.InstanceTemplate("Template", {
61 ...templateProps,
62 });
63 const manager = yield* GCP.Compute.InstanceGroupManager("Manager", {
64 zone,
65 instanceTemplate: template.templateName,
66 targetSize: 0,
67 description: "test mig",
68 namedPorts: [{ name: "http", port: 80 }],
69 });
70 return { template, manager };
71 }),
72 );
73
74 expect(created.manager.managerName).toEqual(expect.any(String));
75 expect(created.manager.zone).toEqual(zone);
76 expect(created.manager.targetSize).toEqual(0);
77 expect(created.manager.description).toEqual("test mig");
78 expect(created.manager.namedPorts).toEqual([{ name: "http", port: 80 }]);
79 expect(created.manager.project).toEqual(project);
80
81 const fetched = yield* compute.getInstanceGroupManagers({
82 project,
83 zone,
84 instanceGroupManager: created.manager.managerName,
85 });
86 expect(fetched.name).toEqual(created.manager.managerName);
87 expect(fetched.description).toContain("[alchemy ");
88 expect(fetched.description).toContain("test mig");
89 expect(fetched.targetSize).toEqual(0);
90 expect(fetched.namedPorts?.some((port) => port.name === "http")).toEqual(true);
91 expect(fetched.instanceTemplate).toContain(created.template.templateName);
92
93 const updated = yield* stack.deploy(
94 Effect.gen(function* () {
95 const template = yield* GCP.Compute.InstanceTemplate("Template", {
96 ...templateProps,
97 });
98 const manager = yield* GCP.Compute.InstanceGroupManager("Manager", {
99 managerName: created.manager.managerName,
100 zone,
101 instanceTemplate: template.templateName,
102 targetSize: 0,
103 description: "updated mig",
104 namedPorts: [
105 { name: "http", port: 80 },
106 { name: "https", port: 443 },
107 ],
108 });
109 return { template, manager };
110 }),
111 );
112
113 expect(updated.manager.managerName).toEqual(created.manager.managerName);
114 expect(updated.manager.id).toEqual(created.manager.id);
115 expect(updated.manager.description).toEqual("updated mig");
116 expect(updated.manager.namedPorts).toEqual([
117 { name: "http", port: 80 },
118 { name: "https", port: 443 },
119 ]);
120
121 const refetched = yield* compute.getInstanceGroupManagers({
122 project,
123 zone,
124 instanceGroupManager: updated.manager.managerName,
125 });
126 expect(refetched.description).toContain("updated mig");
127 expect((refetched.namedPorts ?? []).map((port) => port.name).sort()).toEqual([
128 "http",
129 "https",
130 ]);
131
132 const replaced = yield* stack.deploy(
133 Effect.gen(function* () {
134 const template = yield* GCP.Compute.InstanceTemplate("Template", {
135 ...templateProps,
136 });
137 const manager = yield* GCP.Compute.InstanceGroupManager("Manager", {
138 managerName: created.manager.managerName,
139 zone: replaceZone,
140 instanceTemplate: template.templateName,
141 targetSize: 0,
142 description: "updated mig",
143 namedPorts: [
144 { name: "http", port: 80 },
145 { name: "https", port: 443 },
146 ],
147 });
148 return { template, manager };
149 }),
150 );
151
152 expect(replaced.manager.managerName).toEqual(created.manager.managerName);
153 expect(replaced.manager.zone).toEqual(replaceZone);
154 expect(replaced.manager.id).not.toEqual(created.manager.id);
155
156 const replacedFetched = yield* compute.getInstanceGroupManagers({
157 project,
158 zone: replaceZone,
159 instanceGroupManager: replaced.manager.managerName,
160 });
161 expect(replacedFetched.zone).toContain(replaceZone);
162 expect(replacedFetched.id).toEqual(replaced.manager.id);
163
164 const oldGone = yield* waitUntilGone(zone, created.manager.managerName);
165 expect(oldGone).toEqual("gone");
166
167 yield* stack.destroy();
168
169 const gone = yield* waitUntilGone(replaceZone, replaced.manager.managerName);
170 expect(gone).toEqual("gone");
171 }).pipe(logLevel),
172 { tags: ["provider:gcp", "provider:gcp:compute", "live"], timeout: 120_000 },
173 );