@devries-cameron20 / t3code Mirror · read-only
Fork 0

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

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 06:00 UTC

main
ts 393 lines 15.8 KB
Raw
1 import * as Hetzner from "@alchemy.run/hetzner";
2 import { waitForAction } from "@alchemy.run/hetzner/actions";
3 import { expect } from "@alchemy.run/test";
4 import * as Test from "@alchemy.run/test/Alchemy";
5 import * as actions from "@distilled.cloud/hetzner/actions";
6 import * as certificates from "@distilled.cloud/hetzner/certificates";
7 import * as Provider from "alchemy/Provider";
8 import * as Effect from "effect/Effect";
9 import { MinimumLogLevel } from "effect/References";
10 import * as Result from "effect/Result";
11 import * as Schedule from "effect/Schedule";
12
13 const { test } = Test.make({ providers: Hetzner.providers() });
14
15 const logLevel = Effect.provideService(MinimumLogLevel, process.env.DEBUG ? "Debug" : "Info");
16
17 const hasHetznerCreds = !!process.env.HCLOUD_TOKEN;
18 const managedEnabled = !!process.env.HCLOUD_TEST_MANAGED_CERT;
19 const managedDomain = process.env.HCLOUD_TEST_MANAGED_CERT_DOMAIN;
20
21 /**
22 * Self-signed RSA-2048 certificates generated once with openssl and checked
23 * in so every test run uploads identical PEMs (never generated at test time):
24 *
25 * ```sh
26 * openssl req -x509 -newkey rsa:2048 -nodes -keyout cert1.key -out cert1.pem \
27 * -days 3650 -subj "/CN=alchemy-hetzner-cert-1.test/O=Alchemy/C=US"
28 * openssl req -x509 -newkey rsa:2048 -nodes -keyout cert2.key -out cert2.pem \
29 * -days 3650 -subj "/CN=alchemy-hetzner-cert-2.test/O=Alchemy/C=US"
30 * ```
31 */
32 const CERT_1 = `-----BEGIN CERTIFICATE-----
33 MIIDBjCCAe4CCQCYVsVxbXZqpzANBgkqhkiG9w0BAQsFADBFMSQwIgYDVQQDDBth
34 bGNoZW15LWhldHpuZXItY2VydC0xLnRlc3QxEDAOBgNVBAoMB0FsY2hlbXkxCzAJ
35 BgNVBAYTAlVTMB4XDTI2MDgxOTAyMzIyNloXDTM2MDgxNjAyMzIyNlowRTEkMCIG
36 A1UEAwwbYWxjaGVteS1oZXR6bmVyLWNlcnQtMS50ZXN0MRAwDgYDVQQKDAdBbGNo
37 ZW15MQswCQYDVQQGEwJVUzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB
38 AMaBAUIwQTo4NGnmAZofYr+rXA3bOzgEQFb3algRdWJ+Nhxb/ztnofTcwSCDAg+G
39 ylGKsmDb2Rn/ycpnWnMZ+TUcChtta1KCd6z5OhM0/qArkN7ymQra7GcquEev9eeO
40 e+YnK71qbE6bpWDvf6KB38iWihEh2yv0WjD7zgYXZ8vaE5s0hXp+TzAphqIs4rqr
41 1WHKOYCJvOxwf3GUS5JmpvfBxEPoVcaEIzita+gq9AQ803ng6i3b2tKTynD2WMgt
42 XioTLx0tLCMsGX4gzTn/ppGzr6h9UTB4Z5z51SvGxBgu1Hflkjbamgt+B8sGAOwa
43 QmYTkKbh9oOZzlwPxzvciCECAwEAATANBgkqhkiG9w0BAQsFAAOCAQEARW7Y+Y3A
44 25HPbn/myawc6RZnO3upBhgwcWGE0uKOC1YFW1aoyUFeKxHTDyUILGyTIruQZzdi
45 oRGaFvgDsJ3w4uFX0GLA5yqqyOmPLwOCAM6jPTPMDo3jTK1GqmhvfEHX1EQSjvBN
46 CQIQRoEoCZ/P8C/S28OHm68xzmoGHVUrkcFF7p5pvYNEmFv5feGnNdETo+PXsYk8
47 34+twQPo+3l2XLMvxZ23LuR5MOYPb2Zngqwr9O3kUGgRaA1d4pOTgKqFnyURpRxP
48 dgm5M499x1rgGi6w2g4iUCdfXRUg0/NmYjRLqzsWiIf2zQY3n3EOZQZpcnSjcw67
49 y9e7q3mdV0YX4g==
50 -----END CERTIFICATE-----
51 `;
52
53 const KEY_1 = `-----BEGIN PRIVATE KEY-----
54 MIIEvgIBADANBgkqhkiG9w0BAQEFAASCBKgwggSkAgEAAoIBAQDGgQFCMEE6ODRp
55 5gGaH2K/q1wN2zs4BEBW92pYEXVifjYcW/87Z6H03MEggwIPhspRirJg29kZ/8nK
56 Z1pzGfk1HAobbWtSgnes+ToTNP6gK5De8pkK2uxnKrhHr/XnjnvmJyu9amxOm6Vg
57 73+igd/IlooRIdsr9Fow+84GF2fL2hObNIV6fk8wKYaiLOK6q9VhyjmAibzscH9x
58 lEuSZqb3wcRD6FXGhCM4rWvoKvQEPNN54Oot29rSk8pw9ljILV4qEy8dLSwjLBl+
59 IM05/6aRs6+ofVEweGec+dUrxsQYLtR35ZI22poLfgfLBgDsGkJmE5Cm4faDmc5c
60 D8c73IghAgMBAAECggEBAJv466s9TVNYrF51WtbmSGpAVCGTHFHkjUWIPKgcd7a/
61 YvcflknwIQLMnndUWT8n8zrlF0oiFNFn+f+u/BQq2XTQpmRssoJvf2eLoQVMg7II
62 6Vk1F+m+oThjCc9SRI8Alvv91VGNGLMfe2/SX+Cp2dO77ZqOlq9P3bpVcMm6hFVY
63 jdgpEmtFroowpmtyh1mZswuf4iQVHhKwKu2nIYmaIPHpzn+M5/nSYJZ6IvQXSsp/
64 s0Vzf28XgEtzD+yzsTf8gUmUoFtv6zmHOtuiZheuSTRUrND5CRRqtyZyKQKeBD00
65 O1jFkn3CDgrwO+Hd/f5Ls6kiXpIoGZmrd68lChce110CgYEA+8kX0WRroawDsQQJ
66 RSP/JmWlPS8I5GZzcNHZzrhbX6YYHXotbK70B2IdPSaU3npdHyDJ0HIi88fLywxY
67 X+zZp3R5OEiBxswIgCYAw6sHLjVUj2g0q25UNE+ELtGJ5wfP8WkoPnsQbS3b61r1
68 YAPbx27uc/oznlYpvl6MemkMya8CgYEAydOZVmOs4p7xRO5OtplMlscdiON8ZAQB
69 l8jYpJvnXN/k+kZzEmFpIZsK43Q0tK7DivsIh7EZS5Fy05TmmqBUDOb/S6++8eX2
70 wB8aN5zb0iAjpJmt8ElkpXBr7G9PqnltkIsBBU8LKCcnPCZH3Gr6Mu+thwoAAAvi
71 vrNaAHpBzy8CgYAxhpWbx2/wZiB3wj58jh8TE21UQpsyKgDNEUoRgmvevZICwlSL
72 C0LO7PqpW5xuwozsoYtw5/J+Fy+76dq8S59oc92gN4rnapzFcDQ4SLzp1u2iI7Iw
73 gkwn2fg7KVZBzmSVrMSQva42e43FlqerUjb53JUk1PMwUux1GK3zKhSs2wKBgFR8
74 OVIKg5KSCllakKSrY34yd9CXubh8XNZXAylVAfLE3qtN1lm5YTLqHhK80FtaVQzW
75 rOlwXzBdAH5FdIsB1m1YPUJHnVzRcQtXebgR94rsXT9H/aH6dyEyAFuG9QhdsFmz
76 dofsYLU8PpZVR/ui5H1yC2fd7cYXM6G0nlZY1zeNAoGBAIslugHQdDguMaTo/D3F
77 aReim26Q1wa0bRoq0Pf96DQjDJFi4tKpDPh/nuVrqhND6r3gySFf0uGHvGvuz3DP
78 QDrbiXojN6AOtwUaqdn2l9J64io3MF5N6GLF/03MfSyUQpTl9BVH/fqQ4o74n9Cr
79 4AYpPy5ePvZaKOxuaOY7o6v7
80 -----END PRIVATE KEY-----
81 `;
82
83 const CERT_2 = `-----BEGIN CERTIFICATE-----
84 MIIDBjCCAe4CCQD19r7W0wv1wDANBgkqhkiG9w0BAQsFADBFMSQwIgYDVQQDDBth
85 bGNoZW15LWhldHpuZXItY2VydC0yLnRlc3QxEDAOBgNVBAoMB0FsY2hlbXkxCzAJ
86 BgNVBAYTAlVTMB4XDTI2MDgxOTAyMzIyNloXDTM2MDgxNjAyMzIyNlowRTEkMCIG
87 A1UEAwwbYWxjaGVteS1oZXR6bmVyLWNlcnQtMi50ZXN0MRAwDgYDVQQKDAdBbGNo
88 ZW15MQswCQYDVQQGEwJVUzCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB
89 ANUS0qNOphwQpQZjxs86IrWR2AQqSNxErdFh8O5nLQIlCdSoTizkM/g8IMoTbNFb
90 KGoFYH+poNKcWuXbqzzmUm6Q2Nd5Iyry+3FEUxh9tu4+ynbGIe8wG/16wuHC2pU/
91 bdj65LYF7X3cazPcPRokRrNxm2E/GxNhju91A8NfilMspUCau3PhKT+h9Bc2lukH
92 a6+eTjFW7LHyo5yXyIi1/hUb7FNgVsCdAQ8cy3Re48Z4ekmhVmwpd+BNMdUNQ0u6
93 FMuV8NwJVuldVNUL9FW6sjjLL9AkMdRcKkOmCRJK8V7Q9dL0/2AvG5Pm2aL/FNiI
94 eEam9wWW9kncjdBTICVuel0CAwEAATANBgkqhkiG9w0BAQsFAAOCAQEAHvU4jLKC
95 a2uqt49j68i6z8GZgyLj4gXI+Xsx26aY7ZqpO2JLubBoh8oDAMAa2MsXFX0cLzjU
96 K75C9/JmtD/eNyN4cx5x2gamw/SA9Of+5MK5MoaGUT3gvYaci0MtG6oVy/rg/6oJ
97 bw+EDhZr2vl1RB1B8W+ioIc//T6h2x//DL5j3sHKBQoPCzkr6eCv4DxpnmT29xNz
98 0IM1CDCraCMagE0Yy8tZUZ6Hx+4xTl51CNdITOjgChx0ml05hi2kXmOoXO1p0QO+
99 g940wVRm3D/w+k/Kcrr3MjD80fYtwR4KsUGI0CDmd4kD0sfLbea5/A2Pa/vpqfL8
100 as0SaX4IMSA4Xw==
101 -----END CERTIFICATE-----
102 `;
103
104 const KEY_2 = `-----BEGIN PRIVATE KEY-----
105 MIIEvAIBADANBgkqhkiG9w0BAQEFAASCBKYwggSiAgEAAoIBAQDVEtKjTqYcEKUG
106 Y8bPOiK1kdgEKkjcRK3RYfDuZy0CJQnUqE4s5DP4PCDKE2zRWyhqBWB/qaDSnFrl
107 26s85lJukNjXeSMq8vtxRFMYfbbuPsp2xiHvMBv9esLhwtqVP23Y+uS2Be193Gsz
108 3D0aJEazcZthPxsTYY7vdQPDX4pTLKVAmrtz4Sk/ofQXNpbpB2uvnk4xVuyx8qOc
109 l8iItf4VG+xTYFbAnQEPHMt0XuPGeHpJoVZsKXfgTTHVDUNLuhTLlfDcCVbpXVTV
110 C/RVurI4yy/QJDHUXCpDpgkSSvFe0PXS9P9gLxuT5tmi/xTYiHhGpvcFlvZJ3I3Q
111 UyAlbnpdAgMBAAECggEAIxs81Wdp+wnLBuh9ozsi6OOkwdrtsk0mjm8isUUSp13O
112 5tjsOH1JCsdtZ54Xuc7ZM866/Y3HT6wvVdwBtMEGJ+15rNbqsnLiduEZB9n+v/Zc
113 iYFPqgc1NWh6n5PpS9ntkWiVMmB7ptcgWqUY9Cux8nLvdPBe16ylTlLrUc92DQnr
114 CCxsJkvAFUbQksrbbUDPRPszpo/DyPzKBckzFq8Y68cqnArkKtlOaPJcx5hxIb6h
115 fLZT1KoBJSgIktVapXVUHbka1ARa2/0ktvTv6INkSF89p25cAkesEIMa1Q1q73ky
116 FoavMYFjbEKgXLRMy9Kr+D8s7fYE1P1fobdqz+LOSQKBgQD105ibO1RGfjjd8jYj
117 SjxU5P29szD9YJBlE3b8hB6+Rjn4VtDz33DtuQ6qJHv6hBQOTXWPxhG7cSVs5Wu0
118 kQjKSDV0GAfAd4RoLWphBExXqhllag0jYJF6BBYVOOyeWecvF57z44UyVNWg4m1Z
119 1dDHm7d6Z/DrIE10ROcFyJEhzwKBgQDd5Dm8xanM95X+QY9PuT72OLdnb5rzJApP
120 i2AHhyur2U/m6x9ugLFVJNGiMLR5NeFJbyje5wJnP0jTI+7Pk0pQLZ6W6ayMt1wD
121 dampwkxWY++3LebM0CqCJ8dx7M2cQY4tufFW6++LIjCMjXBcgdpbM7Q8b0zuBl8N
122 bXpQt92IEwKBgHxf0EhJ3jvERPVWRLnaJ2g0a4T9En4/yw64qGzeU8elNFNHaXTZ
123 ygMcrCS9TNTU2mjaG+7gIbyaZHsSIEo9Txs5KYJRXiqszZr/z2DCkfWQpETBQWBy
124 zWfUhW+7W0xK5ELZSpzOsmdisKszpGvdWEKFsHEIAcaUk1uOOOyeK3/VAoGABeNH
125 cO3hypGLRlrg/aGRvSDWJQV+HBOJvoCZRLnee8nhZ+Q3SkxZ6EN42I/oSgsW9kbf
126 08JXevvf59JdRN7IqwX63lBHBtjatTDLFrkUI3q1YqvyIt8nMZrynOBGuG244xe7
127 Aq5yBcQbe69JGvtLGv5tOulNJke+//E2vKuUUkcCgYA7PG17Scu2+N94/o6bY1GA
128 cGIAvpDoI/4O/+Eq9OAQwGVgax7JvTT2dbmFeZHrsemd0priwn0sLP0aE54nq1x7
129 4Mv53B1l2UJNwJB/sjhBOyALnq5PPzuox8abmFBhJ79+PYpsksE0Rxs3MBsuYg2M
130 MVO4iP/qwP+7FslwWXMKPw==
131 -----END PRIVATE KEY-----
132 `;
133
134 const waitUntilGone = (id: number) =>
135 certificates.getCertificate({ id }).pipe(
136 Effect.as("found" as const),
137 Effect.catchTag("NotFound", () => Effect.succeed("gone" as const)),
138 Effect.repeat({
139 schedule: Schedule.spaced("1 second"),
140 until: (status) => status === "gone",
141 times: 10,
142 }),
143 );
144
145 test.provider.skipIf(!hasHetznerCreds)(
146 "create, update, and delete an uploaded certificate",
147 (stack) =>
148 Effect.gen(function* () {
149 yield* stack.destroy();
150
151 const created = yield* stack.deploy(
152 Effect.gen(function* () {
153 return yield* Hetzner.Certificate("UploadedCert", {
154 certificate: CERT_1,
155 privateKey: KEY_1,
156 labels: { env: "test" },
157 });
158 }),
159 );
160
161 expect(created.id).toEqual(expect.any(Number));
162 expect(created.name).toEqual(expect.any(String));
163 expect(created.type).toEqual("uploaded");
164 expect(created.certificate).toContain("BEGIN CERTIFICATE");
165 expect(created.fingerprint).toEqual(expect.any(String));
166 expect(created.created).toEqual(expect.any(String));
167 expect(created.labels).toMatchObject({ env: "test" });
168
169 const fetched = yield* certificates.getCertificate({ id: created.id });
170 expect(fetched.certificate.id).toEqual(created.id);
171 expect(fetched.certificate.name).toEqual(created.name);
172 expect(fetched.certificate.type).toEqual("uploaded");
173 expect(fetched.certificate.fingerprint).toEqual(created.fingerprint);
174 expect(fetched.certificate.labels.env).toEqual("test");
175
176 const updated = yield* stack.deploy(
177 Effect.gen(function* () {
178 return yield* Hetzner.Certificate("UploadedCert", {
179 name: `${created.name.slice(0, 55)}-renamed`,
180 certificate: CERT_1,
181 privateKey: KEY_1,
182 labels: { env: "prod", role: "edge" },
183 });
184 }),
185 );
186
187 expect(updated.id).toEqual(created.id);
188 expect(updated.fingerprint).toEqual(created.fingerprint);
189 expect(updated.name).toEqual(`${created.name.slice(0, 55)}-renamed`);
190 expect(updated.labels).toMatchObject({ env: "prod", role: "edge" });
191
192 const refetched = yield* certificates.getCertificate({ id: updated.id });
193 expect(refetched.certificate.name).toEqual(updated.name);
194 expect(refetched.certificate.labels.env).toEqual("prod");
195 expect(refetched.certificate.labels.role).toEqual("edge");
196
197 yield* stack.destroy();
198
199 const gone = yield* waitUntilGone(created.id);
200 expect(gone).toEqual("gone");
201 }).pipe(logLevel),
202 {
203 tags: ["provider:hetzner", "provider:hetzner:certificate", "provider:hetzner:service", "live"],
204 timeout: 120_000,
205 },
206 );
207
208 test.provider.skipIf(!hasHetznerCreds)(
209 "replace when the uploaded PEM changes",
210 (stack) =>
211 Effect.gen(function* () {
212 yield* stack.destroy();
213
214 const created = yield* stack.deploy(
215 Effect.gen(function* () {
216 return yield* Hetzner.Certificate("ReplaceCert", {
217 certificate: CERT_1,
218 privateKey: KEY_1,
219 });
220 }),
221 );
222
223 expect(created.type).toEqual("uploaded");
224 expect(created.fingerprint).toEqual(expect.any(String));
225
226 const replaced = yield* stack.deploy(
227 Effect.gen(function* () {
228 return yield* Hetzner.Certificate("ReplaceCert", {
229 name: created.name,
230 certificate: CERT_2,
231 privateKey: KEY_2,
232 });
233 }),
234 );
235
236 expect(replaced.id).not.toEqual(created.id);
237 expect(replaced.fingerprint).not.toEqual(created.fingerprint);
238 expect(replaced.name).toEqual(created.name);
239
240 const fetched = yield* certificates.getCertificate({ id: replaced.id });
241 expect(fetched.certificate.id).toEqual(replaced.id);
242 expect(fetched.certificate.fingerprint).toEqual(replaced.fingerprint);
243
244 const oldGone = yield* waitUntilGone(created.id);
245 expect(oldGone).toEqual("gone");
246
247 yield* stack.destroy();
248
249 const gone = yield* waitUntilGone(replaced.id);
250 expect(gone).toEqual("gone");
251 }).pipe(logLevel),
252 {
253 tags: ["provider:hetzner", "provider:hetzner:certificate", "provider:hetzner:service", "live"],
254 timeout: 120_000,
255 },
256 );
257
258 test.provider.skipIf(!hasHetznerCreds)(
259 "list enumerates the deployed certificate",
260 (stack) =>
261 Effect.gen(function* () {
262 yield* stack.destroy();
263
264 const deployed = yield* stack.deploy(
265 Effect.gen(function* () {
266 return yield* Hetzner.Certificate("ListCert", { certificate: CERT_1, privateKey: KEY_1 });
267 }),
268 );
269
270 const provider = yield* Provider.findProvider(Hetzner.Certificate);
271 const all = yield* provider.list();
272 const found = all.find((cert) => cert.id === deployed.id);
273 expect(found).toBeDefined();
274 expect(found?.name).toEqual(deployed.name);
275 expect(found?.type).toEqual("uploaded");
276 expect(found?.fingerprint).toEqual(deployed.fingerprint);
277
278 yield* stack.destroy();
279
280 const gone = yield* waitUntilGone(deployed.id);
281 expect(gone).toEqual("gone");
282 }).pipe(logLevel),
283 {
284 tags: ["provider:hetzner", "provider:hetzner:certificate", "provider:hetzner:service", "live"],
285 timeout: 120_000,
286 },
287 );
288
289 const MANAGED_PROBE_NAME = "alchemy-test-managed-probe";
290 const MANAGED_PROBE_DOMAIN = "alchemy-unmanaged-probe.example.com";
291
292 test.provider.skipIf(!hasHetznerCreds || managedEnabled)(
293 "managed issuance is rejected when the domain is not in Hetzner DNS",
294 (stack) =>
295 Effect.gen(function* () {
296 yield* stack.destroy();
297
298 const existing = yield* certificates.listCertificates({
299 name: MANAGED_PROBE_NAME,
300 per_page: 50,
301 });
302 yield* Effect.forEach(existing.certificates, (cert) =>
303 certificates
304 .deleteCertificate({ id: cert.id })
305 .pipe(Effect.catchTag("NotFound", () => Effect.void)),
306 );
307
308 const result = yield* Effect.result(
309 certificates.createCertificate({
310 name: MANAGED_PROBE_NAME,
311 type: "managed",
312 domain_names: [MANAGED_PROBE_DOMAIN],
313 }),
314 );
315
316 if (Result.isFailure(result)) {
317 // Hetzner rejects managed issuance for domains it does not host
318 // with 422 `dns_zone_not_found` (typed UnprocessableEntity).
319 expect(result.failure._tag).toEqual("UnprocessableEntity");
320 } else {
321 const { certificate, action } = result.success;
322 const outcome = action ? yield* Effect.result(waitForAction(action)) : undefined;
323 yield* certificates
324 .deleteCertificate({ id: certificate.id })
325 .pipe(Effect.catchTag("NotFound", () => Effect.void));
326 if (outcome !== undefined && Result.isFailure(outcome)) {
327 // Issuance for a domain Hetzner does not host either fails the
328 // Action or is still pending when the bounded poll expires.
329 expect(["ActionFailed", "ActionTimeout"]).toContain(outcome.failure._tag);
330 } else {
331 expect(certificate.status?.issuance).not.toEqual("completed");
332 }
333 }
334
335 yield* stack.destroy();
336 }).pipe(logLevel),
337 {
338 tags: ["provider:hetzner", "provider:hetzner:certificate", "provider:hetzner:service", "live"],
339 timeout: 120_000,
340 },
341 );
342
343 test.provider.skipIf(!hasHetznerCreds || !managedEnabled || !managedDomain)(
344 "create, update, and delete a managed certificate",
345 (stack) =>
346 Effect.gen(function* () {
347 yield* stack.destroy();
348
349 const created = yield* stack.deploy(
350 Effect.gen(function* () {
351 return yield* Hetzner.Certificate("ManagedCert", {
352 type: "managed",
353 domainNames: [managedDomain!],
354 labels: { env: "test" },
355 });
356 }),
357 );
358
359 expect(created.id).toEqual(expect.any(Number));
360 expect(created.type).toEqual("managed");
361 expect(created.domainNames).toContain(managedDomain);
362 expect(created.labels).toMatchObject({ env: "test" });
363
364 const fetched = yield* certificates.getCertificate({ id: created.id });
365 expect(fetched.certificate.id).toEqual(created.id);
366 expect(fetched.certificate.type).toEqual("managed");
367 expect(fetched.certificate.domain_names).toContain(managedDomain);
368
369 const updated = yield* stack.deploy(
370 Effect.gen(function* () {
371 return yield* Hetzner.Certificate("ManagedCert", {
372 type: "managed",
373 name: `${created.name.slice(0, 55)}-renamed`,
374 domainNames: [managedDomain!],
375 labels: { env: "prod" },
376 });
377 }),
378 );
379
380 expect(updated.id).toEqual(created.id);
381 expect(updated.name).toEqual(`${created.name.slice(0, 55)}-renamed`);
382 expect(updated.labels).toMatchObject({ env: "prod" });
383
384 yield* stack.destroy();
385
386 const gone = yield* waitUntilGone(created.id);
387 expect(gone).toEqual("gone");
388 }).pipe(logLevel),
389 {
390 tags: ["provider:hetzner", "provider:hetzner:certificate", "provider:hetzner:service", "live"],
391 timeout: 120_000,
392 },
393 );