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

main
ts 179 lines 6.44 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 waitUntilGone = (project: string, firewallPolicy: string) =>
15 compute.getNetworkFirewallPolicies({ project, firewallPolicy }).pipe(
16 Effect.as("found" as const),
17 Effect.catchTag("NotFound", () => Effect.succeed("gone" as const)),
18 Effect.repeat({
19 schedule: Schedule.spaced("1 second"),
20 until: (status) => status === "gone",
21 times: 10,
22 }),
23 );
24
25 const ruleAt = (rules: compute.FirewallPolicyRule[] | undefined, priority: number) =>
26 (rules ?? []).find((rule) => rule.priority === priority);
27
28 const hasReservedGotoNext = (rules: compute.FirewallPolicyRule[] | undefined) =>
29 (rules ?? []).some(
30 (rule) =>
31 rule.action === "goto_next" &&
32 rule.priority !== undefined &&
33 rule.priority >= 2147483548 &&
34 rule.priority <= 2147483647,
35 );
36
37 const nextName = (name: string) => {
38 const flip = name.endsWith("x") ? "z" : "x";
39 return name.length < 63 ? `${name}${flip}` : `${name.slice(0, -1)}${flip}`;
40 };
41
42 test.provider(
43 "getNetworkFirewallPolicies on a missing policy fails with NotFound",
44 (stack) =>
45 Effect.gen(function* () {
46 yield* stack.destroy();
47 const { project } = yield* GcpEnvironment.current;
48 const error = yield* Effect.flip(
49 compute.getNetworkFirewallPolicies({
50 project,
51 firewallPolicy: "alchemy-missing-nfw",
52 }),
53 );
54 expect(error._tag).toBe("NotFound");
55 yield* stack.destroy();
56 }).pipe(logLevel),
57 { tags: ["provider:gcp", "provider:gcp:compute", "live"], timeout: 90_000 },
58 );
59
60 test.provider(
61 "create, update, replace, and delete a network firewall policy",
62 (stack) =>
63 Effect.gen(function* () {
64 yield* stack.destroy();
65
66 const created = yield* stack.deploy(
67 Effect.gen(function* () {
68 return yield* GCP.Compute.NetworkFirewallPolicy("VpcFw", {
69 description: "allow internal http",
70 rules: [
71 {
72 action: "allow",
73 priority: 1000,
74 direction: "INGRESS",
75 match: {
76 srcIpRanges: ["10.0.0.0/8"],
77 layer4Configs: [{ ipProtocol: "tcp", ports: ["80"] }],
78 },
79 },
80 ],
81 });
82 }),
83 );
84
85 expect(created.networkFirewallPolicyName).toEqual(expect.any(String));
86 expect(created.policyType).toEqual("VPC_POLICY");
87 expect(created.description).toEqual("allow internal http");
88 expect(ruleAt(created.rules, 1000)?.action).toEqual("allow");
89 expect(hasReservedGotoNext(created.rules)).toEqual(true);
90
91 const fetched = yield* compute.getNetworkFirewallPolicies({
92 project: created.project,
93 firewallPolicy: created.networkFirewallPolicyName,
94 });
95 expect(fetched.name).toEqual(created.networkFirewallPolicyName);
96 expect(fetched.description).toContain("[alchemy ");
97 expect(fetched.description).toContain("allow internal http");
98 expect(ruleAt(fetched.rules, 1000)?.match?.srcIpRanges).toEqual(
99 expect.arrayContaining(["10.0.0.0/8"]),
100 );
101
102 const listed = yield* compute.listNetworkFirewallPolicies({
103 project: created.project,
104 maxResults: 500,
105 });
106 expect(
107 (listed.items ?? []).some((policy) => policy.name === created.networkFirewallPolicyName),
108 ).toEqual(true);
109
110 const updated = yield* stack.deploy(
111 Effect.gen(function* () {
112 return yield* GCP.Compute.NetworkFirewallPolicy("VpcFw", {
113 networkFirewallPolicyName: created.networkFirewallPolicyName,
114 description: "updated vpc fw",
115 rules: [
116 {
117 action: "allow",
118 priority: 1000,
119 direction: "INGRESS",
120 description: "http and https",
121 match: {
122 srcIpRanges: ["10.0.0.0/8", "192.168.0.0/16"],
123 layer4Configs: [{ ipProtocol: "tcp", ports: ["80", "443"] }],
124 },
125 },
126 ],
127 });
128 }),
129 );
130
131 expect(updated.networkFirewallPolicyName).toEqual(created.networkFirewallPolicyName);
132 expect(updated.networkFirewallPolicyId).toEqual(created.networkFirewallPolicyId);
133 expect(updated.description).toEqual("updated vpc fw");
134 expect(ruleAt(updated.rules, 1000)?.match?.srcIpRanges?.slice().sort()).toEqual([
135 "10.0.0.0/8",
136 "192.168.0.0/16",
137 ]);
138
139 const fetchedUpdate = yield* compute.getNetworkFirewallPolicies({
140 project: updated.project,
141 firewallPolicy: updated.networkFirewallPolicyName,
142 });
143 expect(fetchedUpdate.description).toContain("updated vpc fw");
144 expect(ruleAt(fetchedUpdate.rules, 1000)?.description).toEqual("http and https");
145
146 const replaced = yield* stack.deploy(
147 Effect.gen(function* () {
148 return yield* GCP.Compute.NetworkFirewallPolicy("VpcFw", {
149 networkFirewallPolicyName: nextName(created.networkFirewallPolicyName),
150 description: "replaced vpc fw",
151 rules: [
152 {
153 action: "deny",
154 priority: 1000,
155 direction: "INGRESS",
156 match: {
157 srcIpRanges: ["0.0.0.0/0"],
158 layer4Configs: [{ ipProtocol: "tcp", ports: ["23"] }],
159 },
160 },
161 ],
162 });
163 }),
164 );
165
166 expect(replaced.networkFirewallPolicyName).toEqual(
167 nextName(created.networkFirewallPolicyName),
168 );
169 expect(replaced.networkFirewallPolicyId).not.toEqual(created.networkFirewallPolicyId);
170 expect(replaced.description).toEqual("replaced vpc fw");
171 expect(ruleAt(replaced.rules, 1000)?.action).toEqual("deny");
172
173 yield* stack.destroy();
174
175 const gone = yield* waitUntilGone(replaced.project, replaced.networkFirewallPolicyName);
176 expect(gone).toEqual("gone");
177 }).pipe(logLevel),
178 { tags: ["provider:gcp", "provider:gcp:compute", "live"], timeout: 180_000 },
179 );