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

main
ts 147 lines 5.21 KB
Raw
1 import * as GCP from "@alchemy.run/gcp";
2 import { GcpEnvironment } from "@alchemy.run/gcp/Environment";
3 import { describe, expect } from "@alchemy.run/test";
4 import * as Test from "@alchemy.run/test/Alchemy";
5 import * as Core from "@alchemy.run/test/Core";
6 import * as resourcemanager from "@distilled.cloud/gcp/cloudresourcemanager_v3";
7 import * as parametermanager from "@distilled.cloud/gcp/parametermanager_v1";
8 import * as Effect from "effect/Effect";
9 import { expectProbe } from "../bindingHost.ts";
10 import ParameterManagerBindingsHost, { AppConfig, PAYLOAD, V1 } from "./fixtures/bindings-host.ts";
11
12 const testOptions = { providers: GCP.providers() };
13 const { test, beforeAll, afterAll } = Test.make(testOptions);
14 const sharedStack = Core.scratchStack(testOptions, "ParameterManagerBindings");
15
16 let baseUrl: string;
17 let member: string;
18 let parameterName: string;
19 let versionName: string;
20
21 const scoped = (name: string) =>
22 `resource.name == "${name}" || resource.name.startsWith("${name}/")`;
23
24 /** `[role, condition expression]` the host holds on the project. */
25 const hostProjectGrants = Effect.gen(function* () {
26 const { project } = yield* GcpEnvironment.current;
27 const policy = yield* resourcemanager.getIamPolicyProjects({
28 resource: `projects/${project}`,
29 body: { options: { requestedPolicyVersion: 3 } },
30 });
31 return (policy.bindings ?? [])
32 .filter((binding) => (binding.members ?? []).includes(member))
33 .map((binding) => [binding.role, binding.condition?.expression]);
34 });
35
36 const base64 = (text: string) => Buffer.from(text, "utf8").toString("base64");
37
38 describe(
39 "ParameterManager Bindings",
40 {
41 tags: ["provider:gcp", "provider:gcp:parametermanager", "provider:gcp:run", "live"],
42 },
43 () => {
44 beforeAll(
45 Effect.gen(function* () {
46 yield* sharedStack.destroy();
47 const out = yield* sharedStack.deploy(
48 Effect.gen(function* () {
49 const host = yield* ParameterManagerBindingsHost;
50 return {
51 uri: host.uri,
52 serviceAccount: host.serviceAccount,
53 parameter: (yield* AppConfig).name,
54 version: (yield* V1).name,
55 };
56 }),
57 );
58 baseUrl = out.uri!;
59 member = `serviceAccount:${out.serviceAccount!}`;
60 parameterName = out.parameter;
61 versionName = out.version;
62 }),
63 { timeout: 900_000 },
64 );
65
66 afterAll(sharedStack.destroy(), { timeout: 600_000 });
67
68 describe("GetParameter", () => {
69 test.provider(
70 "reads the parameter, granted parameterViewer scoped to it",
71 (_stack) =>
72 Effect.gen(function* () {
73 const live = yield* expectProbe<parametermanager.Parameter>(baseUrl, "getParameter");
74 expect(live.name).toEqual(parameterName);
75 expect(live.format).toEqual("JSON");
76
77 expect(yield* hostProjectGrants).toContainEqual([
78 "roles/parametermanager.parameterViewer",
79 scoped(parameterName),
80 ]);
81 }),
82 {
83 tags: ["provider:gcp", "provider:gcp:parametermanager", "live"],
84 timeout: 600_000,
85 },
86 );
87 });
88
89 describe("GetParameterVersion", () => {
90 test.provider(
91 "reads the version payload, granted parameterViewer scoped to it",
92 (_stack) =>
93 Effect.gen(function* () {
94 const live = yield* expectProbe<parametermanager.ParameterVersion>(
95 baseUrl,
96 "getParameterVersion",
97 );
98 expect(live.name).toEqual(versionName);
99 expect(live.payload?.data).toEqual(base64(PAYLOAD));
100
101 expect(yield* hostProjectGrants).toContainEqual([
102 "roles/parametermanager.parameterViewer",
103 scoped(versionName),
104 ]);
105 }),
106 {
107 tags: ["provider:gcp", "provider:gcp:parametermanager", "live"],
108 timeout: 600_000,
109 },
110 );
111 });
112
113 describe("RenderParameterVersion", () => {
114 test.provider(
115 "renders the version, granted parameterAccessor scoped to it",
116 (_stack) =>
117 Effect.gen(function* () {
118 const rendered = yield* expectProbe<parametermanager.RenderParameterVersionResponse>(
119 baseUrl,
120 "renderParameterVersion",
121 );
122 expect(rendered.parameterVersion).toEqual(versionName);
123 expect(rendered.renderedPayload).toEqual(base64(PAYLOAD));
124
125 // Out of band: the deployer renders the same payload.
126 const direct = yield* parametermanager.renderProjectsLocationsParametersVersions({
127 name: versionName,
128 });
129 expect(direct.renderedPayload).toEqual(rendered.renderedPayload);
130
131 const grants = yield* hostProjectGrants;
132 expect(grants).toContainEqual([
133 "roles/parametermanager.parameterAccessor",
134 scoped(versionName),
135 ]);
136 // Every grant the host holds is condition-scoped.
137 expect(grants.filter(([, expression]) => !expression)).toEqual([]);
138 expect(grants).toHaveLength(3);
139 }),
140 {
141 tags: ["provider:gcp", "provider:gcp:parametermanager", "live"],
142 timeout: 600_000,
143 },
144 );
145 });
146 },
147 );