@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, 04:45 UTC

main
ts 132 lines 4.45 KB
Raw
1 import * as AWS from "@alchemy.run/aws";
2 import * as Cloudflare from "@alchemy.run/cloudflare";
3 import { bucketStorageClient, type BucketAttributes } from "@alchemy.run/neon/Bucket";
4 import { storageBodyBytes } from "@alchemy.run/neon/Object";
5 import { providers } from "@alchemy.run/neon/Providers";
6 import { expect } from "@alchemy.run/test";
7 import * as Test from "@alchemy.run/test/Alchemy";
8 import * as SDK from "@distilled.cloud/neon";
9 import * as Effect from "effect/Effect";
10 import * as HttpClient from "effect/http/HttpClient";
11 import * as Layer from "effect/Layer";
12 import * as Schedule from "effect/Schedule";
13 import StorageHttpLambda from "./fixtures/StorageHttpLambda.ts";
14 import StorageHttpWorker from "./fixtures/StorageHttpWorker.ts";
15 import { StorageBucket } from "./fixtures/StorageResources.ts";
16
17 const { test: workerTest } = Test.make({
18 providers: Layer.mergeAll(providers(), Cloudflare.providers()),
19 });
20 const { test: lambdaTest } = Test.make({
21 providers: Layer.mergeAll(providers(), AWS.providers()),
22 });
23
24 const verify = Effect.fn(function* (url: string, bucket: BucketAttributes) {
25 const http = HttpClient.filterStatusOk(yield* HttpClient.HttpClient);
26 const response = yield* http
27 .get(`${url}/write`)
28 .pipe(Effect.retry({ schedule: Schedule.spaced("3 seconds"), times: 8 }));
29 expect(response.status).toBe(200);
30 expect(yield* (yield* http.get(url)).json).toEqual({
31 size: 18,
32 hasAccountKey: false,
33 });
34 const client = yield* bucketStorageClient(bucket);
35 const bytes = yield* storageBodyBytes((yield* client.get("external.txt"))?.Body);
36 expect(yield* Effect.sync(() => new TextDecoder().decode(bytes))).toBe("external roundtrip");
37 const scope = { project_id: bucket.projectId, branch_id: bucket.branchId };
38 const credentials = (yield* SDK.listCredentials(scope)).credentials.filter(
39 (credential) => credential.branch_id === bucket.branchId && !credential.revoked_at,
40 );
41 expect(
42 credentials.map((credential) => credential.scopes).sort((a, b) => a.length - b.length),
43 ).toEqual([
44 ["storage:read"],
45 ["storage:read", "storage:write"],
46 ["storage:read", "storage:write"],
47 ]);
48 return credentials
49 .filter((credential) => credential.token_id !== bucket.credential.tokenId)
50 .map((credential) => credential.token_id);
51 });
52
53 workerTest.provider(
54 "Worker HTTP storage uses scoped credentials and revokes them when unbound",
55 (stack) =>
56 Effect.gen(function* () {
57 yield* stack.destroy();
58 const { worker, bucket } = yield* stack.deploy(
59 Effect.gen(function* () {
60 return {
61 worker: yield* StorageHttpWorker,
62 bucket: yield* StorageBucket,
63 };
64 }),
65 );
66 const tokens = yield* verify(worker.url!, bucket);
67 yield* stack.deploy(StorageBucket);
68 const remaining = (yield* SDK.listCredentials({
69 project_id: bucket.projectId,
70 branch_id: bucket.branchId,
71 })).credentials;
72 expect(
73 remaining.some(
74 (credential) => tokens.includes(credential.token_id) && !credential.revoked_at,
75 ),
76 ).toBe(false);
77 yield* stack.destroy();
78 yield* stack.destroy();
79 }),
80 {
81 tags: [
82 "provider:cloudflare",
83 "provider:cloudflare:worker",
84 "provider:neon",
85 "provider:neon:branch",
86 "provider:neon:bucket",
87 "provider:neon:object",
88 "provider:neon:project",
89 "live",
90 ],
91 timeout: 120_000,
92 },
93 );
94
95 lambdaTest.provider(
96 "Lambda HTTP storage uses namespaced non-account secrets",
97 (stack) =>
98 Effect.gen(function* () {
99 yield* stack.destroy();
100 const { fn, bucket } = yield* stack.deploy(
101 Effect.gen(function* () {
102 return { fn: yield* StorageHttpLambda, bucket: yield* StorageBucket };
103 }),
104 );
105 const tokens = yield* verify(fn.functionUrl!, bucket);
106 yield* stack.deploy(StorageBucket);
107 const remaining = (yield* SDK.listCredentials({
108 project_id: bucket.projectId,
109 branch_id: bucket.branchId,
110 })).credentials;
111 expect(
112 remaining.some(
113 (credential) => tokens.includes(credential.token_id) && !credential.revoked_at,
114 ),
115 ).toBe(false);
116 yield* stack.destroy();
117 yield* stack.destroy();
118 }),
119 {
120 tags: [
121 "provider:aws",
122 "provider:aws:lambda",
123 "provider:neon",
124 "provider:neon:branch",
125 "provider:neon:bucket",
126 "provider:neon:object",
127 "provider:neon:project",
128 "live",
129 ],
130 timeout: 240_000,
131 },
132 );