@devries-cameron20 / t3code Mirror · read-only
Fork 0

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

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 21, 06:00 UTC

main
ts 175 lines 6 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 crm from "@distilled.cloud/gcp/cloudresourcemanager_v3";
7 import * as documentai from "@distilled.cloud/gcp/documentai_v1";
8 import * as Effect from "effect/Effect";
9 import { expectProbe } from "../bindingHost.ts";
10 import DocumentAIBindingsHost, { Invoice, InvoiceV1, OcrBind } 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, "DocumentAIBindings");
15
16 let baseUrl: string;
17 let hostAccount: string;
18 let processorName: string;
19 let schemaName: string;
20 let versionName: string;
21
22 /**
23 * Document AI has no resource-level IAM, so its bindings grant on the
24 * project: `documentai.viewer` (GetProcessor / GetSchema / GetSchemaVersion)
25 * and `documentai.apiUser` (Process).
26 */
27 const expectProjectGrants = Effect.gen(function* () {
28 const { project } = yield* GcpEnvironment.current;
29 const policy = yield* crm.getIamPolicyProjects({
30 resource: `projects/${project}`,
31 body: { options: { requestedPolicyVersion: 3 } },
32 });
33 const grants = (policy.bindings ?? [])
34 .filter((binding) => (binding.members ?? []).includes(`serviceAccount:${hostAccount}`))
35 .map((binding) => ({
36 role: binding.role,
37 condition: binding.condition?.expression,
38 }))
39 .sort((a, b) => (a.role ?? "").localeCompare(b.role ?? ""));
40 expect(grants).toEqual([
41 { role: "roles/documentai.apiUser", condition: undefined },
42 { role: "roles/documentai.viewer", condition: undefined },
43 ]);
44 });
45
46 describe.skipIf(!!process.env.FAST)(
47 "DocumentAI Bindings",
48 {
49 tags: ["provider:gcp", "provider:gcp:documentai", "provider:gcp:run", "live"],
50 },
51 () => {
52 beforeAll(
53 Effect.gen(function* () {
54 yield* sharedStack.destroy();
55 const out = yield* sharedStack.deploy(
56 Effect.gen(function* () {
57 const host = yield* DocumentAIBindingsHost;
58 const processor = yield* OcrBind;
59 const schema = yield* Invoice;
60 const version = yield* InvoiceV1;
61 return {
62 uri: host.uri,
63 serviceAccount: host.serviceAccount,
64 processor: processor.name,
65 schema: schema.name,
66 version: version.name,
67 };
68 }),
69 );
70 baseUrl = out.uri!;
71 hostAccount = out.serviceAccount!;
72 processorName = out.processor;
73 schemaName = out.schema;
74 versionName = out.version;
75 }),
76 { timeout: 900_000 },
77 );
78
79 afterAll(sharedStack.destroy(), { timeout: 600_000 });
80
81 describe("GetProcessor", () => {
82 test.provider(
83 "reads the processor as the host's service account",
84 (_stack) =>
85 Effect.gen(function* () {
86 const processor = yield* expectProbe<documentai.GoogleCloudDocumentaiV1Processor>(
87 baseUrl,
88 "getProcessor",
89 );
90 const live = yield* documentai.getProjectsLocationsProcessors({
91 name: processorName,
92 });
93 expect(processor.name).toEqual(processorName);
94 expect(processor.type).toEqual("OCR_PROCESSOR");
95 expect(processor.displayName).toEqual(live.displayName);
96 yield* expectProjectGrants;
97 }),
98 {
99 tags: ["provider:gcp", "provider:gcp:documentai", "live"],
100 timeout: 600_000,
101 },
102 );
103 });
104
105 describe("Process", () => {
106 test.provider(
107 "OCRs a PDF as the host's service account",
108 (_stack) =>
109 Effect.gen(function* () {
110 const processed = yield* expectProbe<{
111 text?: string;
112 pages?: number;
113 }>(baseUrl, "process");
114 expect(processed.pages).toEqual(1);
115 expect(processed.text).toContain("Hello");
116 yield* expectProjectGrants;
117 }),
118 {
119 tags: ["provider:gcp", "provider:gcp:documentai", "live"],
120 timeout: 600_000,
121 },
122 );
123 });
124
125 describe("GetSchema", () => {
126 test.provider(
127 "reads the schema as the host's service account",
128 (_stack) =>
129 Effect.gen(function* () {
130 const schema = yield* expectProbe<documentai.GoogleCloudDocumentaiV1NextSchema>(
131 baseUrl,
132 "getSchema",
133 );
134 const live = yield* documentai.getProjectsLocationsSchemas({
135 name: schemaName,
136 });
137 expect(schema.name).toEqual(schemaName);
138 expect(schema.displayName).toEqual("invoice-bind");
139 expect(schema.labels).toEqual(live.labels);
140 yield* expectProjectGrants;
141 }),
142 {
143 tags: ["provider:gcp", "provider:gcp:documentai", "live"],
144 timeout: 600_000,
145 },
146 );
147 });
148
149 describe("GetSchemaVersion", () => {
150 test.provider(
151 "reads the schema version as the host's service account",
152 (_stack) =>
153 Effect.gen(function* () {
154 const version = yield* expectProbe<documentai.GoogleCloudDocumentaiV1SchemaVersion>(
155 baseUrl,
156 "getSchemaVersion",
157 );
158 const live = yield* documentai.getProjectsLocationsSchemasSchemaVersions({
159 name: versionName,
160 });
161 expect(version.name).toEqual(versionName);
162 expect(version.displayName).toEqual("v1");
163 expect(
164 version.schema?.entityTypes?.[0]?.properties?.map((property) => property.name),
165 ).toEqual(live.schema?.entityTypes?.[0]?.properties?.map((property) => property.name));
166 yield* expectProjectGrants;
167 }),
168 {
169 tags: ["provider:gcp", "provider:gcp:documentai", "live"],
170 timeout: 600_000,
171 },
172 );
173 });
174 },
175 );