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

main
ts 168 lines 5.42 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 cloudrun from "@distilled.cloud/gcp/run_v2";
6 import * as Effect from "effect/Effect";
7 import * as HttpClient from "effect/http/HttpClient";
8 import { expectProbe } from "../bindingHost.ts";
9 import RunBindingsHost, { Api, Callee, Migrate, Workers } from "./fixtures/bindings-host.ts";
10
11 const testOptions = { providers: GCP.providers() };
12 const { test, beforeAll, afterAll } = Test.make(testOptions);
13 const sharedStack = Core.scratchStack(testOptions, "RunBindings");
14
15 let baseUrl: string;
16 let member: string;
17 let names: {
18 api: string;
19 callee: string;
20 calleeUri: string;
21 workers: string;
22 job: string;
23 };
24
25 type Policy = { bindings?: { role?: string; members?: string[] }[] };
26
27 const rolesOf = (policy: Policy) =>
28 (policy.bindings ?? [])
29 .filter((binding) => (binding.members ?? []).includes(member))
30 .map((binding) => binding.role)
31 .sort();
32
33 const serviceRoles = (name: string) =>
34 cloudrun
35 .getIamPolicyProjectsLocationsServices({
36 resource: name,
37 "options.requestedPolicyVersion": 3,
38 })
39 .pipe(Effect.map(rolesOf));
40
41 describe("Run Bindings", { tags: ["provider:gcp", "provider:gcp:run", "live"] }, () => {
42 beforeAll(
43 Effect.gen(function* () {
44 yield* sharedStack.destroy();
45 const out = yield* sharedStack.deploy(
46 Effect.gen(function* () {
47 const host = yield* RunBindingsHost;
48 const callee = yield* Callee;
49 return {
50 uri: host.uri,
51 serviceAccount: host.serviceAccount,
52 api: (yield* Api).name,
53 callee: callee.name,
54 calleeUri: callee.uri,
55 workers: (yield* Workers).name,
56 job: (yield* Migrate).name,
57 };
58 }),
59 );
60 baseUrl = out.uri!;
61 member = `serviceAccount:${out.serviceAccount!}`;
62 names = { ...out, calleeUri: out.calleeUri! };
63 }),
64 { timeout: 900_000 },
65 );
66
67 afterAll(sharedStack.destroy(), { timeout: 600_000 });
68
69 describe("GetService", () => {
70 test.provider(
71 "reads the service, granted viewer on the service only",
72 (_stack) =>
73 Effect.gen(function* () {
74 const live = yield* expectProbe<cloudrun.GoogleCloudRunV2Service>(baseUrl, "getService");
75 expect(live.name).toEqual(names.api);
76 expect(live.template?.containers?.[0]?.image).toEqual(
77 "us-docker.pkg.dev/cloudrun/container/hello",
78 );
79 expect(yield* serviceRoles(names.api)).toEqual(["roles/run.viewer"]);
80 }),
81 {
82 tags: ["provider:gcp", "provider:gcp:run", "live"],
83 timeout: 600_000,
84 },
85 );
86 });
87
88 describe("GetWorkerPool", () => {
89 test.provider(
90 "reads the worker pool, granted viewer on the pool only",
91 (_stack) =>
92 Effect.gen(function* () {
93 const live = yield* expectProbe<cloudrun.GoogleCloudRunV2WorkerPool>(
94 baseUrl,
95 "getWorkerPool",
96 );
97 expect(live.name).toEqual(names.workers);
98
99 const policy = yield* cloudrun.getIamPolicyProjectsLocationsWorkerPools({
100 resource: names.workers,
101 "options.requestedPolicyVersion": 3,
102 });
103 expect(rolesOf(policy)).toEqual(["roles/run.viewer"]);
104 }),
105 {
106 tags: ["provider:gcp", "provider:gcp:run", "live"],
107 timeout: 600_000,
108 },
109 );
110 });
111
112 describe("RunJob", () => {
113 test.provider(
114 "starts an execution, granted jobsExecutorWithOverrides on the job only",
115 (_stack) =>
116 Effect.gen(function* () {
117 const operation = yield* expectProbe<cloudrun.GoogleLongrunningOperation>(
118 baseUrl,
119 "runJob",
120 );
121 const executionName = operation.metadata?.name;
122 expect(typeof executionName).toEqual("string");
123 expect(String(executionName)).toContain(`${names.job}/executions/`);
124
125 // Out of band: the execution exists under the bound job.
126 const execution = yield* cloudrun.getProjectsLocationsJobsExecutions({
127 name: String(executionName),
128 });
129 expect(execution.name).toEqual(executionName);
130
131 const policy = yield* cloudrun.getIamPolicyProjectsLocationsJobs({
132 resource: names.job,
133 "options.requestedPolicyVersion": 3,
134 });
135 expect(rolesOf(policy)).toEqual(["roles/run.jobsExecutorWithOverrides"]);
136 }),
137 {
138 tags: ["provider:gcp", "provider:gcp:run", "live"],
139 timeout: 600_000,
140 },
141 );
142 });
143
144 describe("InvokeService", () => {
145 test.provider(
146 "calls the private service with an ID token, granted invoker on it only",
147 (_stack) =>
148 Effect.gen(function* () {
149 const out = yield* expectProbe<{ status: number; text: string }>(
150 baseUrl,
151 "invokeService",
152 );
153 expect(out.status).toEqual(200);
154 expect(out.text).toContain("It's running!");
155
156 // Without a token Cloud Run rejects the call at its front end.
157 const direct = yield* HttpClient.get(names.calleeUri);
158 expect(direct.status).toEqual(403);
159
160 expect(yield* serviceRoles(names.callee)).toEqual(["roles/run.invoker"]);
161 }),
162 {
163 tags: ["provider:gcp", "provider:gcp:run", "live"],
164 timeout: 600_000,
165 },
166 );
167 });
168 });