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

main
ts 166 lines 6.17 KB
Raw
1 import * as GCP from "@alchemy.run/gcp";
2 import { expect } from "@alchemy.run/test";
3 import * as Test from "@alchemy.run/test/Alchemy";
4 import * as compute from "@distilled.cloud/gcp/compute_v1";
5 import * as Effect from "effect/Effect";
6 import { MinimumLogLevel } from "effect/References";
7 import * as Schedule from "effect/Schedule";
8 import { CERT_A_PEM, CERT_B_PEM, KEY_A_PEM, KEY_B_PEM } from "./fixtures/https-proxy-cert.ts";
9
10 const { test } = Test.make({ providers: GCP.providers() });
11
12 const logLevel = Effect.provideService(MinimumLogLevel, process.env.DEBUG ? "Debug" : "Info");
13
14 const region = "us-central1";
15
16 const waitUntilGone = (project: string, targetHttpsProxyName: string) =>
17 compute
18 .getRegionTargetHttpsProxies({
19 project,
20 region,
21 targetHttpsProxy: targetHttpsProxyName,
22 })
23 .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 const resourceTail = (value: string | undefined): string => {
34 if (value === undefined || value.length === 0) return "";
35 const parts = value.split("/").filter((part) => part.length > 0);
36 return parts[parts.length - 1] ?? "";
37 };
38
39 test.provider(
40 "create, update, and delete a regional target https proxy",
41 (stack) =>
42 Effect.gen(function* () {
43 yield* stack.destroy();
44
45 const created = yield* stack.deploy(
46 Effect.gen(function* () {
47 const map = yield* GCP.Compute.RegionUrlMap("Web", {
48 region,
49 description: "https redirect",
50 defaultUrlRedirect: {
51 httpsRedirect: true,
52 hostRedirect: "example.com",
53 stripQuery: false,
54 },
55 });
56 const cert = yield* GCP.Compute.RegionSslCertificate("TlsA", {
57 region,
58 description: "frontend tls a",
59 certificate: CERT_A_PEM,
60 privateKey: KEY_A_PEM,
61 });
62 const proxy = yield* GCP.Compute.RegionTargetHttpsProxy("Proxy", {
63 region,
64 description: "https frontend",
65 urlMap: map.urlMapName,
66 sslCertificates: [cert.sslCertificateName],
67 });
68 return { map, cert, proxy };
69 }),
70 );
71
72 expect(created.proxy.targetHttpsProxyName).toEqual(expect.any(String));
73 expect(created.proxy.region).toEqual(region);
74 expect(created.proxy.description).toEqual("https frontend");
75 expect(resourceTail(created.proxy.urlMap)).toEqual(created.map.urlMapName);
76 expect(created.proxy.sslCertificates.map(resourceTail)).toContain(
77 created.cert.sslCertificateName,
78 );
79
80 const fetched = yield* compute.getRegionTargetHttpsProxies({
81 project: created.proxy.project,
82 region,
83 targetHttpsProxy: created.proxy.targetHttpsProxyName,
84 });
85 expect(fetched.name).toEqual(created.proxy.targetHttpsProxyName);
86 expect(resourceTail(fetched.urlMap)).toEqual(resourceTail(created.proxy.urlMap));
87 expect(fetched.description).toContain("[alchemy ");
88 expect(fetched.description).toContain("https frontend");
89 expect((fetched.sslCertificates ?? []).map(resourceTail)).toContain(
90 created.cert.sslCertificateName,
91 );
92
93 const updated = yield* stack.deploy(
94 Effect.gen(function* () {
95 yield* GCP.Compute.RegionUrlMap("Web", {
96 urlMapName: created.map.urlMapName,
97 region,
98 description: "https redirect",
99 defaultUrlRedirect: {
100 httpsRedirect: true,
101 hostRedirect: "example.com",
102 stripQuery: false,
103 },
104 });
105 const other = yield* GCP.Compute.RegionUrlMap("Other", {
106 region,
107 description: "alt redirect",
108 defaultUrlRedirect: {
109 httpsRedirect: true,
110 hostRedirect: "example.org",
111 stripQuery: true,
112 },
113 });
114 yield* GCP.Compute.RegionSslCertificate("TlsA", {
115 sslCertificateName: created.cert.sslCertificateName,
116 region,
117 description: "frontend tls a",
118 certificate: CERT_A_PEM,
119 privateKey: KEY_A_PEM,
120 });
121 const certB = yield* GCP.Compute.RegionSslCertificate("TlsB", {
122 region,
123 description: "frontend tls b",
124 certificate: CERT_B_PEM,
125 privateKey: KEY_B_PEM,
126 });
127 const proxy = yield* GCP.Compute.RegionTargetHttpsProxy("Proxy", {
128 targetHttpsProxyName: created.proxy.targetHttpsProxyName,
129 region,
130 description: "updated https",
131 urlMap: other.urlMapName,
132 sslCertificates: [certB.sslCertificateName],
133 });
134 return { other, certB, proxy };
135 }),
136 );
137
138 expect(updated.proxy.targetHttpsProxyName).toEqual(created.proxy.targetHttpsProxyName);
139 expect(updated.proxy.description).toEqual("updated https");
140 expect(resourceTail(updated.proxy.urlMap)).toEqual(updated.other.urlMapName);
141 expect(updated.proxy.sslCertificates.map(resourceTail)).toContain(
142 updated.certB.sslCertificateName,
143 );
144 expect(updated.proxy.sslCertificates.map(resourceTail)).not.toContain(
145 created.cert.sslCertificateName,
146 );
147
148 const refetched = yield* compute.getRegionTargetHttpsProxies({
149 project: updated.proxy.project,
150 region,
151 targetHttpsProxy: updated.proxy.targetHttpsProxyName,
152 });
153 expect(refetched.description).toContain("updated https");
154 expect(resourceTail(refetched.urlMap)).toEqual(resourceTail(updated.proxy.urlMap));
155 expect(resourceTail(refetched.urlMap)).not.toEqual(resourceTail(created.proxy.urlMap));
156 expect((refetched.sslCertificates ?? []).map(resourceTail)).toContain(
157 updated.certB.sslCertificateName,
158 );
159
160 yield* stack.destroy();
161
162 const gone = yield* waitUntilGone(created.proxy.project, created.proxy.targetHttpsProxyName);
163 expect(gone).toEqual("gone");
164 }).pipe(logLevel),
165 { tags: ["provider:gcp", "provider:gcp:compute", "live"], timeout: 90_000 },
166 );