The best way to control Claude Code, Codex and more from any computer or phone
| 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 | ); |