@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 244 lines 10.2 KB
Raw
1 import { createHash } from "node:crypto";
2 import * as GCP from "@alchemy.run/gcp";
3 import { makeGcsState } from "@alchemy.run/gcp";
4 import { createStateBucketName } from "@alchemy.run/gcp/StateStore/State";
5 import { makeObjectMedia } from "@alchemy.run/gcp/Storage/ObjectMedia";
6 import { expect } from "@alchemy.run/test";
7 import * as Test from "@alchemy.run/test/Alchemy";
8 import * as storage from "@distilled.cloud/gcp/storage_v1";
9 import { StateStoreError, type ResourceState, type StateService } from "alchemy/State";
10 import * as Effect from "effect/Effect";
11 import * as Schedule from "effect/Schedule";
12 import * as Stream from "effect/Stream";
13
14 const { test } = Test.make({ providers: GCP.providers() });
15
16 const STACK = "GcsStateStoreTestStack";
17
18 const tags = ["provider:gcp", "provider:gcp:storage", "provider:gcp:statestore", "live"];
19
20 const cleanStage = (state: StateService, stage: string) =>
21 state.deleteStack({ stack: STACK, stage }).pipe(Effect.orDie);
22
23 const resource = (fqn: string, attr: Record<string, unknown>): ResourceState =>
24 ({
25 resourceType: "test:resource",
26 namespace: undefined,
27 fqn,
28 logicalId: fqn,
29 instanceId: `instance-${fqn}`,
30 providerVersion: 1,
31 status: "created",
32 downstream: [],
33 bindings: [],
34 props: {},
35 attr,
36 }) as ResourceState;
37
38 /** Delete every object generation, then the bucket. Missing is fine. */
39 const deleteBucket = (bucket: string) =>
40 Effect.gen(function* () {
41 yield* storage.listObjects.pages({ bucket, versions: true }).pipe(
42 Stream.flatMap((page) => Stream.fromIterable(page.items ?? [])),
43 Stream.runForEach((object) =>
44 storage
45 .deleteObjects({ bucket, object: object.name!, generation: object.generation })
46 .pipe(Effect.catchTag("NotFound", () => Effect.void)),
47 ),
48 );
49 yield* storage.deleteBuckets({ bucket }).pipe(
50 Effect.catchTag("NotFound", () => Effect.void),
51 Effect.retry({
52 while: (error) => error._tag === "Conflict",
53 schedule: Schedule.spaced("1 second"),
54 times: 8,
55 }),
56 );
57 }).pipe(Effect.catchTag("NotFound", () => Effect.void));
58
59 test.provider(
60 "set/get/list/delete round-trips state through Cloud Storage",
61 (stack) =>
62 Effect.gen(function* () {
63 yield* stack.destroy();
64 const bucket = yield* stack.deploy(GCP.Storage.Bucket("StateBucket", { forceDestroy: true }));
65 const state = yield* makeGcsState({ bucketName: bucket.bucketName, prefix: "test-state" });
66 const stage = "round-trip";
67
68 yield* state.deleteStack({ stack: STACK, stage });
69
70 yield* Effect.gen(function* () {
71 const a = resource("Parent/ResourceA", { value: "a" });
72 const b = resource("ResourceB", { value: "b" });
73
74 yield* state.set({ stack: STACK, stage, fqn: a.fqn, value: a });
75 yield* state.set({ stack: STACK, stage, fqn: b.fqn, value: b });
76
77 expect(yield* state.get({ stack: STACK, stage, fqn: a.fqn })).toEqual(a);
78 expect(yield* state.get({ stack: STACK, stage, fqn: "does-not-exist" })).toBeUndefined();
79
80 const fqns = yield* state.list({ stack: STACK, stage });
81 expect([...fqns].sort()).toEqual(["Parent/ResourceA", "ResourceB"]);
82
83 expect(yield* state.listStacks()).toContain(STACK);
84 expect(yield* state.listStages(STACK)).toContain(stage);
85
86 yield* state.delete({ stack: STACK, stage, fqn: a.fqn });
87 expect(yield* state.get({ stack: STACK, stage, fqn: a.fqn })).toBeUndefined();
88 // deleting a missing resource is a no-op
89 yield* state.delete({ stack: STACK, stage, fqn: a.fqn });
90
91 yield* state.setOutput({ stack: STACK, stage, value: { url: "https://example.com" } });
92 expect(yield* state.getOutput({ stack: STACK, stage })).toEqual({
93 url: "https://example.com",
94 });
95 // the output bookkeeping object must not leak into list()
96 expect(yield* state.list({ stack: STACK, stage })).toEqual(["ResourceB"]);
97
98 yield* state.deleteStack({ stack: STACK, stage });
99 expect(yield* state.list({ stack: STACK, stage })).toEqual([]);
100 expect(yield* state.getOutput({ stack: STACK, stage })).toBeUndefined();
101 }).pipe(Effect.ensuring(cleanStage(state, stage)));
102 yield* stack.destroy();
103 }),
104 { tags, timeout: 120_000 },
105 );
106
107 test.provider(
108 "a second Cloud Storage state store cannot write a stage another deploy holds",
109 (stack) =>
110 Effect.gen(function* () {
111 yield* stack.destroy();
112 const bucket = yield* stack.deploy(GCP.Storage.Bucket("StateBucket", { forceDestroy: true }));
113 const options = { bucketName: bucket.bucketName, prefix: "lease" };
114 const stage = "race";
115 const created = resource("Vpc", { vpcId: "vpc-aaaa" });
116 const request = { stack: STACK, stage, fqn: created.fqn, value: created };
117
118 yield* Effect.scoped(
119 Effect.gen(function* () {
120 const held = yield* makeGcsState(options);
121 yield* held.set(request);
122 const other = yield* makeGcsState(options);
123 const error = yield* other
124 .set({ ...request, value: { ...created, attr: { vpcId: "vpc-bbbb" } } })
125 .pipe(Effect.flip);
126 expect(error).toBeInstanceOf(StateStoreError);
127 expect(error.message).toContain("another deploy holds the Cloud Storage state lock");
128 expect(yield* held.get({ stack: STACK, stage, fqn: created.fqn })).toMatchObject({
129 attr: { vpcId: "vpc-aaaa" },
130 });
131 // The lease object is not a resource row.
132 expect(yield* held.list({ stack: STACK, stage })).toEqual([created.fqn]);
133 }),
134 );
135
136 // The first store's scope has closed and released the lease.
137 yield* Effect.scoped(
138 Effect.gen(function* () {
139 const next = yield* makeGcsState(options);
140 yield* next.set({ ...request, value: { ...created, attr: { vpcId: "vpc-cccc" } } });
141 expect(yield* next.get({ stack: STACK, stage, fqn: created.fqn })).toMatchObject({
142 attr: { vpcId: "vpc-cccc" },
143 });
144 yield* next.deleteStack({ stack: STACK, stage });
145 }),
146 );
147
148 // Closing the store deletes its lease, so a destroyed stage is no
149 // longer listed.
150 const after = yield* makeGcsState(options);
151 expect(yield* after.listStages(STACK)).not.toContain(stage);
152 yield* stack.destroy();
153 }),
154 { tags, timeout: 120_000 },
155 );
156
157 test.provider(
158 "an expired Cloud Storage state lease can be taken and a live one cannot",
159 (stack) =>
160 Effect.gen(function* () {
161 yield* stack.destroy();
162 const bucket = yield* stack.deploy(GCP.Storage.Bucket("StateBucket", { forceDestroy: true }));
163 const prefix = "lease-expiry";
164 const state = yield* makeGcsState({ bucketName: bucket.bucketName, prefix });
165 const expiredStage = "expired";
166 const heldStage = "held";
167 const leaseKey = (stage: string) => `${prefix}/${STACK}/${stage}/__lease__.json`;
168 const writer = yield* makeObjectMedia;
169 const putLease = (stage: string, expiresAt: number) =>
170 writer.upload(bucket.bucketName, {
171 name: leaseKey(stage),
172 body: JSON.stringify({ token: "foreign", expiresAt }),
173 contentType: "application/json",
174 });
175
176 yield* putLease(expiredStage, 0);
177 const created = resource("Group", { groupId: "sg-aaaa" });
178 yield* state.set({ stack: STACK, stage: expiredStage, fqn: created.fqn, value: created });
179 expect(yield* state.list({ stack: STACK, stage: expiredStage })).toEqual([created.fqn]);
180
181 yield* putLease(heldStage, Date.now() + 60_000);
182 const blocked = yield* state
183 .set({ stack: STACK, stage: heldStage, fqn: created.fqn, value: created })
184 .pipe(Effect.flip);
185 expect(blocked).toBeInstanceOf(StateStoreError);
186 expect(blocked.message).toContain("another deploy holds the Cloud Storage state lock");
187
188 yield* storage
189 .deleteObjects({ bucket: bucket.bucketName, object: leaseKey(heldStage) })
190 .pipe(Effect.catchTag("NotFound", () => Effect.void));
191 yield* state.deleteStack({ stack: STACK, stage: expiredStage });
192 yield* stack.destroy();
193 }),
194 { tags, timeout: 120_000 },
195 );
196
197 test.provider(
198 "first use creates the state bucket with secure defaults",
199 (stack) =>
200 Effect.gen(function* () {
201 const { project } = yield* GCP.GcpEnvironment.current;
202 // A store name unique to this test and stage, so runs never share a
203 // bucket.
204 const name = `it-${createHash("sha256").update(stack.stage).digest("hex").slice(0, 10)}`;
205 const bucketName = createStateBucketName(project, name);
206 yield* deleteBucket(bucketName);
207
208 yield* Effect.gen(function* () {
209 const state = yield* makeGcsState({ name });
210 expect(yield* state.listStacks()).toEqual([]);
211
212 const created = yield* storage.getBuckets({ bucket: bucketName });
213 expect(created.iamConfiguration?.uniformBucketLevelAccess?.enabled).toBe(true);
214 expect(created.iamConfiguration?.publicAccessPrevention).toBe("enforced");
215 expect(created.versioning?.enabled).toBe(true);
216
217 // Uniform access leaves project owners unable to read objects, so
218 // the store grants them (and editors) object access.
219 const policy = yield* storage.getIamPolicyBuckets({ bucket: bucketName });
220 const objectAdmin = policy.bindings?.find(
221 (binding) => binding.role === "roles/storage.objectAdmin",
222 );
223 expect(objectAdmin?.members).toEqual(
224 expect.arrayContaining([`projectOwner:${project}`, `projectEditor:${project}`]),
225 );
226
227 // Drift is converged on the next first use.
228 yield* storage.patchBuckets({
229 bucket: bucketName,
230 body: { versioning: { enabled: false } },
231 });
232 const again = yield* makeGcsState({ name });
233 expect(yield* again.listStacks()).toEqual([]);
234 expect((yield* storage.getBuckets({ bucket: bucketName })).versioning?.enabled).toBe(true);
235 }).pipe(Effect.ensuring(deleteBucket(bucketName).pipe(Effect.orDie)));
236
237 const gone = yield* storage.getBuckets({ bucket: bucketName }).pipe(
238 Effect.as(false),
239 Effect.catchTag("NotFound", () => Effect.succeed(true)),
240 );
241 expect(gone).toBe(true);
242 }),
243 { tags, timeout: 120_000 },
244 );