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

main
ts 254 lines 8.56 KB
Raw
1 import * as GCP from "@alchemy.run/gcp";
2 import { describe, expect } from "@alchemy.run/test";
3 import * as Test from "@alchemy.run/test/Alchemy";
4 import * as Core from "@alchemy.run/test/Core";
5 import * as secretmanager from "@distilled.cloud/gcp/secretmanager_v1";
6 import * as Effect from "effect/Effect";
7 import { expectProbe } from "../bindingHost.ts";
8 import SecretManagerBindingsHost, {
9 OpsSecret,
10 ReadOnlySecret,
11 ReadWriteOnlySecret,
12 RegionalSecret,
13 SEEDED,
14 WriteOnlySecret,
15 } from "./fixtures/bindings-host.ts";
16
17 const testOptions = { providers: GCP.providers() };
18 const { test, beforeAll, afterAll } = Test.make(testOptions);
19 const sharedStack = Core.scratchStack(testOptions, "SecretManagerBindings");
20
21 let baseUrl: string;
22 let hostAccount: string;
23 let secrets: {
24 ops: string;
25 regional: string;
26 readOnly: string;
27 writeOnly: string;
28 readWrite: string;
29 };
30
31 const hostRoles = (policy: secretmanager.Policy) =>
32 (policy.bindings ?? [])
33 .filter((binding) => (binding.members ?? []).includes(`serviceAccount:${hostAccount}`))
34 .map((binding) => binding.role)
35 .sort();
36
37 /** Roles the host's service account holds on a global secret. */
38 const secretRoles = (name: string) =>
39 secretmanager.getIamPolicyProjectsSecrets({ resource: name }).pipe(Effect.map(hostRoles));
40
41 /** Roles the host's service account holds on a regional secret. */
42 const regionalSecretRoles = (name: string) =>
43 secretmanager
44 .getIamPolicyProjectsLocationsSecrets({ resource: name })
45 .pipe(Effect.map(hostRoles));
46
47 /** Every version of a secret with its state, read out of band. */
48 const versionStates = (parent: string) =>
49 Effect.gen(function* () {
50 const states: Record<string, string | undefined> = {};
51 let pageToken: string | undefined;
52 do {
53 const page = yield* secretmanager.listProjectsSecretsVersions({
54 parent,
55 pageToken,
56 });
57 for (const version of page.versions ?? []) {
58 if (version.name) states[version.name] = version.state;
59 }
60 pageToken = page.nextPageToken;
61 } while (pageToken);
62 return states;
63 });
64
65 describe(
66 "SecretManager Bindings",
67 {
68 tags: ["provider:gcp", "provider:gcp:secretmanager", "provider:gcp:run", "live"],
69 },
70 () => {
71 beforeAll(
72 Effect.gen(function* () {
73 yield* sharedStack.destroy();
74 const out = yield* sharedStack.deploy(
75 Effect.gen(function* () {
76 const host = yield* SecretManagerBindingsHost;
77 return {
78 uri: host.uri,
79 serviceAccount: host.serviceAccount,
80 ops: (yield* OpsSecret).name,
81 regional: (yield* RegionalSecret).name,
82 readOnly: (yield* ReadOnlySecret).name,
83 writeOnly: (yield* WriteOnlySecret).name,
84 readWrite: (yield* ReadWriteOnlySecret).name,
85 };
86 }),
87 );
88 baseUrl = out.uri!;
89 hostAccount = out.serviceAccount!;
90 secrets = {
91 ops: out.ops,
92 regional: out.regional,
93 readOnly: out.readOnly,
94 writeOnly: out.writeOnly,
95 readWrite: out.readWrite,
96 };
97 }),
98 { timeout: 900_000 },
99 );
100
101 afterAll(sharedStack.destroy(), { timeout: 600_000 });
102
103 describe("AddSecretVersion / AccessSecretVersion", () => {
104 test.provider(
105 "round-trip a global secret as the host's service account, granted on the secret only",
106 (_stack) =>
107 Effect.gen(function* () {
108 const out = yield* expectProbe<{
109 version: string;
110 accessedName: string;
111 data: string;
112 payload: string;
113 }>(baseUrl, "ops");
114 expect(out.version.startsWith(`${secrets.ops}/versions/`)).toBe(true);
115 expect(out.accessedName).toEqual(out.version);
116 expect(out.data).toEqual(out.payload);
117
118 const states = yield* versionStates(secrets.ops);
119 expect(states[out.version]).toEqual("ENABLED");
120
121 expect(yield* secretRoles(secrets.ops)).toEqual([
122 "roles/secretmanager.secretAccessor",
123 "roles/secretmanager.secretVersionAdder",
124 ]);
125 }),
126 {
127 tags: ["provider:gcp", "provider:gcp:secretmanager", "live"],
128 timeout: 600_000,
129 },
130 );
131
132 test.provider(
133 "round-trip a regional secret as the host's service account, granted on the secret only",
134 (_stack) =>
135 Effect.gen(function* () {
136 const out = yield* expectProbe<{
137 version: string;
138 accessedName: string;
139 data: string;
140 payload: string;
141 }>(baseUrl, "opsRegional");
142 expect(out.version.startsWith(`${secrets.regional}/versions/`)).toBe(true);
143 expect(out.version).toContain("/locations/us-central1/secrets/");
144 expect(out.accessedName).toEqual(out.version);
145 expect(out.data).toEqual(out.payload);
146
147 expect(yield* regionalSecretRoles(secrets.regional)).toEqual([
148 "roles/secretmanager.secretAccessor",
149 "roles/secretmanager.secretVersionAdder",
150 ]);
151 }),
152 {
153 tags: ["provider:gcp", "provider:gcp:secretmanager", "live"],
154 timeout: 600_000,
155 },
156 );
157 });
158
159 describe("ReadSecret", () => {
160 test.provider(
161 "reads a seeded version as the host's service account, granted secretAccessor on the secret only",
162 (_stack) =>
163 Effect.gen(function* () {
164 yield* secretmanager.addVersionProjectsSecrets({
165 parent: secrets.readOnly,
166 body: {
167 payload: { data: btoa(SEEDED) },
168 },
169 });
170 const out = yield* expectProbe<{
171 latest: string;
172 bytes: string;
173 missing: boolean;
174 }>(baseUrl, "read");
175 expect(out).toEqual({
176 latest: SEEDED,
177 bytes: SEEDED,
178 missing: true,
179 });
180
181 expect(yield* secretRoles(secrets.readOnly)).toEqual([
182 "roles/secretmanager.secretAccessor",
183 ]);
184 }),
185 {
186 tags: ["provider:gcp", "provider:gcp:secretmanager", "live"],
187 timeout: 600_000,
188 },
189 );
190 });
191
192 describe("WriteSecret", () => {
193 test.provider(
194 "adds, disables and destroys versions as the host's service account, granted secretVersionManager on the secret only",
195 (_stack) =>
196 Effect.gen(function* () {
197 const out = yield* expectProbe<{ v1: string; v2: string }>(baseUrl, "write");
198 expect(out.v1.startsWith(`${secrets.writeOnly}/versions/`)).toBe(true);
199 expect(out.v2.startsWith(`${secrets.writeOnly}/versions/`)).toBe(true);
200
201 const states = yield* versionStates(secrets.writeOnly);
202 expect(states[out.v1]).toEqual("DESTROYED");
203 expect(states[out.v2]).toEqual("DISABLED");
204
205 expect(yield* secretRoles(secrets.writeOnly)).toEqual([
206 "roles/secretmanager.secretVersionManager",
207 ]);
208 }),
209 {
210 tags: ["provider:gcp", "provider:gcp:secretmanager", "live"],
211 timeout: 600_000,
212 },
213 );
214 });
215
216 describe("ReadWriteSecret", () => {
217 test.provider(
218 "rotates and reads back as the host's service account, granted accessor + versionManager on the secret only",
219 (_stack) =>
220 Effect.gen(function* () {
221 const out = yield* expectProbe<{
222 v1: string;
223 v2: string;
224 latest: string;
225 first: string;
226 disabledReadsUndefined: boolean;
227 destroyedReadsUndefined: boolean;
228 }>(baseUrl, "readWrite");
229 expect(out).toEqual({
230 v1: expect.stringContaining(`${secrets.readWrite}/versions/`),
231 v2: expect.stringContaining(`${secrets.readWrite}/versions/`),
232 latest: "two",
233 first: "one",
234 disabledReadsUndefined: true,
235 destroyedReadsUndefined: true,
236 });
237
238 const states = yield* versionStates(secrets.readWrite);
239 expect(states[out.v1]).toEqual("DESTROYED");
240 expect(states[out.v2]).toEqual("DISABLED");
241
242 expect(yield* secretRoles(secrets.readWrite)).toEqual([
243 "roles/secretmanager.secretAccessor",
244 "roles/secretmanager.secretVersionManager",
245 ]);
246 }),
247 {
248 tags: ["provider:gcp", "provider:gcp:secretmanager", "live"],
249 timeout: 600_000,
250 },
251 );
252 });
253 },
254 );