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

main
ts 128 lines 4.58 KB
Raw
1 import * as GCP from "@alchemy.run/gcp";
2 import { GcpEnvironment } from "@alchemy.run/gcp/Environment";
3 import { expect } from "@alchemy.run/test";
4 import * as Test from "@alchemy.run/test/Alchemy";
5 import * as spanner from "@distilled.cloud/gcp/spanner_v1";
6 import * as Effect from "effect/Effect";
7 import { MinimumLogLevel } from "effect/References";
8 import * as Schedule from "effect/Schedule";
9
10 const { test } = Test.make({ providers: GCP.providers() });
11
12 const logLevel = Effect.provideService(MinimumLogLevel, process.env.DEBUG ? "Debug" : "Info");
13
14 const runLifecycle = !process.env.FAST;
15
16 const expireInDays = (days: number) =>
17 new Date(Date.now() + days * 24 * 60 * 60 * 1000).toISOString();
18
19 const waitUntilGone = (name: string) =>
20 spanner.getProjectsInstancesBackups({ name }).pipe(
21 Effect.as("found" as const),
22 Effect.catchTag("NotFound", () => Effect.succeed("gone" as const)),
23 Effect.repeat({
24 schedule: Schedule.spaced("2 seconds"),
25 until: (status) => status === "gone",
26 times: 10,
27 }),
28 );
29
30 test.provider(
31 "getProjectsInstancesBackups on a missing backup fails with NotFound",
32 (stack) =>
33 Effect.gen(function* () {
34 const { project } = yield* GcpEnvironment.current;
35 yield* stack.destroy();
36
37 const error = yield* Effect.flip(
38 spanner.getProjectsInstancesBackups({
39 name: `projects/${project}/instances/alchemy-spanner-missing/backups/alchemy-missing`,
40 }),
41 );
42 expect(error._tag).toBe("NotFound");
43
44 yield* stack.destroy();
45 }).pipe(logLevel),
46 { tags: ["provider:gcp", "provider:gcp:spanner", "live"], timeout: 90_000 },
47 );
48
49 test.provider.skipIf(!runLifecycle)(
50 "create, update, and delete a spanner backup",
51 (stack) =>
52 Effect.gen(function* () {
53 yield* stack.destroy();
54
55 const firstExpire = expireInDays(8);
56 const secondExpire = expireInDays(14);
57
58 const created = yield* stack.deploy(
59 Effect.gen(function* () {
60 const instance = yield* GCP.Spanner.Instance("App", {
61 config: "regional-us-central1",
62 processingUnits: 100,
63 displayName: "alchemy-bk-spnr",
64 defaultBackupScheduleType: "NONE",
65 });
66 const database = yield* GCP.Spanner.Database("AppDb", {
67 instance: instance.instanceId,
68 });
69 const backup = yield* GCP.Spanner.InstancesBackup("Nightly", {
70 instance: instance.instanceId,
71 database: database.databaseId,
72 expireTime: firstExpire,
73 });
74 return { instance, database, backup };
75 }),
76 );
77
78 expect(created.backup.name).toContain("/backups/");
79 expect(created.backup.backupId).toEqual(expect.any(String));
80 expect(created.backup.instanceId).toEqual(created.instance.instanceId);
81 expect(created.backup.database).toEqual(created.database.name);
82 expect(["CREATING", "READY"]).toContain(created.backup.state);
83
84 const fetched = yield* spanner.getProjectsInstancesBackups({
85 name: created.backup.name,
86 });
87 expect(fetched.name).toEqual(created.backup.name);
88 expect(fetched.database).toEqual(created.database.name);
89 expect(["CREATING", "READY"]).toContain(fetched.state);
90
91 const updated = yield* stack.deploy(
92 Effect.gen(function* () {
93 const instance = yield* GCP.Spanner.Instance("App", {
94 instanceId: created.instance.instanceId,
95 config: "regional-us-central1",
96 processingUnits: 100,
97 displayName: "alchemy-bk-spnr",
98 defaultBackupScheduleType: "NONE",
99 });
100 const database = yield* GCP.Spanner.Database("AppDb", {
101 instance: instance.instanceId,
102 databaseId: created.database.databaseId,
103 });
104 const backup = yield* GCP.Spanner.InstancesBackup("Nightly", {
105 instance: instance.instanceId,
106 database: database.databaseId,
107 backupId: created.backup.backupId,
108 expireTime: secondExpire,
109 });
110 return { instance, database, backup };
111 }),
112 );
113
114 expect(updated.backup.name).toEqual(created.backup.name);
115 expect(updated.backup.expireTime).toEqual(expect.any(String));
116
117 const refetched = yield* spanner.getProjectsInstancesBackups({
118 name: created.backup.name,
119 });
120 expect(refetched.name).toEqual(created.backup.name);
121
122 yield* stack.destroy();
123
124 const gone = yield* waitUntilGone(created.backup.name);
125 expect(gone).toEqual("gone");
126 }).pipe(logLevel),
127 { tags: ["provider:gcp", "provider:gcp:spanner", "live"], timeout: 180_000 },
128 );