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

main
ts 220 lines 6.83 KB
Raw
1 import * as Hetzner from "@alchemy.run/hetzner";
2 import { expect } from "@alchemy.run/test";
3 import * as Test from "@alchemy.run/test/Alchemy";
4 import * as primaryIps from "@distilled.cloud/hetzner/primary_ips";
5 import * as Provider from "alchemy/Provider";
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: Hetzner.providers() });
11
12 const logLevel = Effect.provideService(MinimumLogLevel, process.env.DEBUG ? "Debug" : "Info");
13
14 const hasHetznerCreds = !!process.env.HCLOUD_TOKEN;
15
16 const waitUntilGone = (id: number) =>
17 primaryIps.getPrimaryIp({ id }).pipe(
18 Effect.as("found" as const),
19 Effect.catchTag("NotFound", () => Effect.succeed("gone" as const)),
20 Effect.repeat({
21 schedule: Schedule.spaced("1 second"),
22 until: (status) => status === "gone",
23 times: 10,
24 }),
25 );
26
27 test.provider.skipIf(!hasHetznerCreds)(
28 "create, update, and delete an unassigned ipv6 primary ip",
29 (stack) =>
30 Effect.gen(function* () {
31 yield* stack.destroy();
32
33 const created = yield* stack.deploy(
34 Effect.gen(function* () {
35 return yield* Hetzner.PrimaryIp("WebIp", {
36 type: "ipv6",
37 location: "nbg1",
38 labels: { env: "test" },
39 });
40 }),
41 );
42
43 expect(created.id).toEqual(expect.any(Number));
44 expect(created.name).toEqual(expect.any(String));
45 expect(created.type).toEqual("ipv6");
46 expect(created.ip).toEqual(expect.any(String));
47 expect(created.location).toEqual("nbg1");
48 expect(created.locationId).toEqual(expect.any(Number));
49 expect(created.autoDelete).toEqual(false);
50 expect(created.deleteProtection).toEqual(false);
51 expect(created.assigneeId).toBeNull();
52 expect(created.labels).toMatchObject({ env: "test" });
53
54 const fetched = yield* primaryIps.getPrimaryIp({
55 id: created.id,
56 });
57 expect(fetched.primary_ip.id).toEqual(created.id);
58 expect(fetched.primary_ip.type).toEqual("ipv6");
59 expect(fetched.primary_ip.ip).toEqual(created.ip);
60 expect(fetched.primary_ip.location.name).toEqual("nbg1");
61 expect(fetched.primary_ip.auto_delete).toEqual(false);
62 expect(fetched.primary_ip.assignee_id).toBeNull();
63 expect(fetched.primary_ip.labels.env).toEqual("test");
64
65 const updated = yield* stack.deploy(
66 Effect.gen(function* () {
67 return yield* Hetzner.PrimaryIp("WebIp", {
68 type: "ipv6",
69 location: "nbg1",
70 autoDelete: true,
71 labels: { env: "prod", role: "web" },
72 });
73 }),
74 );
75
76 expect(updated.id).toEqual(created.id);
77 expect(updated.ip).toEqual(created.ip);
78 expect(updated.autoDelete).toEqual(true);
79 expect(updated.labels).toMatchObject({ env: "prod", role: "web" });
80
81 const refetched = yield* primaryIps.getPrimaryIp({
82 id: updated.id,
83 });
84 expect(refetched.primary_ip.auto_delete).toEqual(true);
85 expect(refetched.primary_ip.labels.env).toEqual("prod");
86 expect(refetched.primary_ip.labels.role).toEqual("web");
87
88 yield* stack.destroy();
89
90 const gone = yield* waitUntilGone(created.id);
91 expect(gone).toEqual("gone");
92 }).pipe(logLevel),
93 {
94 tags: ["provider:hetzner", "provider:hetzner:primaryip", "provider:hetzner:service", "live"],
95 timeout: 180_000,
96 },
97 );
98
99 test.provider.skipIf(!hasHetznerCreds)(
100 "replace when location changes",
101 (stack) =>
102 Effect.gen(function* () {
103 yield* stack.destroy();
104
105 const created = yield* stack.deploy(
106 Effect.gen(function* () {
107 return yield* Hetzner.PrimaryIp("ReplaceIp", {
108 type: "ipv6",
109 location: "nbg1",
110 });
111 }),
112 );
113
114 expect(created.location).toEqual("nbg1");
115 const previousId = Number(created.id);
116 const previousIp = String(created.ip);
117
118 const replaced = yield* stack.deploy(
119 Effect.gen(function* () {
120 return yield* Hetzner.PrimaryIp("ReplaceIp", {
121 type: "ipv6",
122 location: "fsn1",
123 });
124 }),
125 );
126
127 expect(replaced.id).not.toEqual(previousId);
128 expect(replaced.type).toEqual("ipv6");
129 expect(replaced.ip).not.toEqual(previousIp);
130 expect(replaced.location).toEqual("fsn1");
131 expect(replaced.assigneeId).toBeNull();
132
133 const fetched = yield* primaryIps.getPrimaryIp({
134 id: replaced.id,
135 });
136 expect(fetched.primary_ip.location.name).toEqual("fsn1");
137
138 const oldGone = yield* waitUntilGone(created.id);
139 expect(oldGone).toEqual("gone");
140
141 yield* stack.destroy();
142
143 const gone = yield* waitUntilGone(replaced.id);
144 expect(gone).toEqual("gone");
145 }).pipe(logLevel),
146 {
147 tags: ["provider:hetzner", "provider:hetzner:primaryip", "provider:hetzner:service", "live"],
148 timeout: 180_000,
149 },
150 );
151
152 test.provider.skipIf(!hasHetznerCreds)(
153 "create from datacenter name",
154 (stack) =>
155 Effect.gen(function* () {
156 yield* stack.destroy();
157
158 const created = yield* stack.deploy(
159 Effect.gen(function* () {
160 return yield* Hetzner.PrimaryIp("DatacenterIp", {
161 type: "ipv6",
162 datacenter: "nbg1-dc3",
163 });
164 }),
165 );
166
167 expect(created.location).toEqual("nbg1");
168 expect(created.datacenter).toEqual("nbg1-dc3");
169 expect(created.type).toEqual("ipv6");
170 expect(created.assigneeId).toBeNull();
171
172 const fetched = yield* primaryIps.getPrimaryIp({
173 id: created.id,
174 });
175 expect(fetched.primary_ip.location.name).toEqual("nbg1");
176
177 yield* stack.destroy();
178
179 const gone = yield* waitUntilGone(created.id);
180 expect(gone).toEqual("gone");
181 }).pipe(logLevel),
182 {
183 tags: ["provider:hetzner", "provider:hetzner:primaryip", "provider:hetzner:service", "live"],
184 timeout: 180_000,
185 },
186 );
187
188 test.provider.skipIf(!hasHetznerCreds)(
189 "list enumerates the deployed primary ip",
190 (stack) =>
191 Effect.gen(function* () {
192 yield* stack.destroy();
193
194 const deployed = yield* stack.deploy(
195 Effect.gen(function* () {
196 return yield* Hetzner.PrimaryIp("ListIp", {
197 type: "ipv6",
198 location: "nbg1",
199 });
200 }),
201 );
202
203 const provider = yield* Provider.findProvider(Hetzner.PrimaryIp);
204 const all = yield* provider.list();
205 const found = all.find((ip) => ip.id === deployed.id);
206 expect(found).toBeDefined();
207 expect(found?.type).toEqual("ipv6");
208 expect(found?.location).toEqual("nbg1");
209 expect(found?.ip).toEqual(deployed.ip);
210
211 yield* stack.destroy();
212
213 const gone = yield* waitUntilGone(deployed.id);
214 expect(gone).toEqual("gone");
215 }).pipe(logLevel),
216 {
217 tags: ["provider:hetzner", "provider:hetzner:primaryip", "provider:hetzner:service", "live"],
218 timeout: 180_000,
219 },
220 );