@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 192 lines 7.42 KB
Raw
1 import * as AWS from "@alchemy.run/aws";
2 import { DBCluster, DBInstance, DBSubnetGroup } from "@alchemy.run/aws/Neptune";
3 import { expect } from "@alchemy.run/test";
4 import * as Test from "@alchemy.run/test/Alchemy";
5 import * as EC2 from "@distilled.cloud/aws/ec2";
6 import * as neptune from "@distilled.cloud/aws/neptune";
7 import * as Effect from "effect/Effect";
8 import * as Schedule from "effect/Schedule";
9 import { getDefaultVpc } from "../DefaultVpc.ts";
10
11 const { test } = Test.make({ providers: AWS.providers() });
12
13 // Ungated typed-error probes: prove the distilled error union carries the
14 // not-found tags this provider's read/delete paths depend on. These run in
15 // every CI pass at near-zero cost, unlike the gated lifecycle below.
16 test.provider(
17 "describeDBClusters on a nonexistent cluster fails with DBClusterNotFoundFault",
18 () =>
19 Effect.gen(function* () {
20 const error = yield* Effect.flip(
21 neptune.describeDBClusters({
22 DBClusterIdentifier: "alchemy-nonexistent-neptune-cluster-probe",
23 }),
24 );
25 expect(error._tag).toBe("DBClusterNotFoundFault");
26 }),
27 { tags: ["provider:aws", "provider:aws:neptune", "live"] },
28 );
29
30 test.provider(
31 "describeDBInstances on a nonexistent instance fails with DBInstanceNotFoundFault",
32 () =>
33 Effect.gen(function* () {
34 const error = yield* Effect.flip(
35 neptune.describeDBInstances({
36 DBInstanceIdentifier: "alchemy-nonexistent-neptune-instance-probe",
37 }),
38 );
39 expect(error._tag).toBe("DBInstanceNotFoundFault");
40 }),
41 { tags: ["provider:aws", "provider:aws:neptune", "live"] },
42 );
43
44 test.provider(
45 "describeDBSubnetGroups on a nonexistent group fails with DBSubnetGroupNotFoundFault",
46 () =>
47 Effect.gen(function* () {
48 const error = yield* Effect.flip(
49 neptune.describeDBSubnetGroups({
50 DBSubnetGroupName: "alchemy-nonexistent-neptune-subnet-probe",
51 }),
52 );
53 expect(error._tag).toBe("DBSubnetGroupNotFoundFault");
54 }),
55 { tags: ["provider:aws", "provider:aws:neptune", "live"] },
56 );
57
58 test.provider(
59 "describeDBClusterParameterGroups on a nonexistent group fails with DBParameterGroupNotFoundFault",
60 () =>
61 Effect.gen(function* () {
62 const error = yield* Effect.flip(
63 neptune.describeDBClusterParameterGroups({
64 DBClusterParameterGroupName: "alchemy-nonexistent-neptune-params-probe",
65 }),
66 );
67 expect(error._tag).toBe("DBParameterGroupNotFoundFault");
68 }),
69 { tags: ["provider:aws", "provider:aws:neptune", "live"] },
70 );
71
72 // Resolve two default-for-AZ subnets and the default security group.
73 const defaultNetwork = Effect.gen(function* () {
74 const vpc = yield* getDefaultVpc;
75 const subnets = yield* EC2.describeSubnets({
76 Filters: [
77 { Name: "vpc-id", Values: [vpc.vpcId] },
78 { Name: "default-for-az", Values: ["true"] },
79 ],
80 });
81 const subnetIds = (subnets.Subnets ?? [])
82 .map((s) => s.SubnetId)
83 .filter((id): id is `subnet-${string}` => id !== undefined)
84 .sort()
85 .slice(0, 2);
86 const groups = yield* EC2.describeSecurityGroups({
87 Filters: [
88 { Name: "vpc-id", Values: [vpc.vpcId] },
89 { Name: "group-name", Values: ["default"] },
90 ],
91 });
92 const securityGroupId = groups.SecurityGroups?.[0]?.GroupId;
93 if (subnetIds.length < 2 || securityGroupId === undefined) {
94 return yield* Effect.die(
95 new Error("default VPC is missing subnets or its default security group"),
96 );
97 }
98 return { subnetIds, securityGroupIds: [securityGroupId] };
99 });
100
101 // Deletion is verified as INITIATED (status `deleting`, irreversible) or fully
102 // gone. Full disappearance takes several more minutes server-side; waiting for
103 // it would push the test into its timeout.
104 const assertClusterDeleting = (identifier: string) =>
105 Effect.gen(function* () {
106 const status = yield* neptune.describeDBClusters({ DBClusterIdentifier: identifier }).pipe(
107 Effect.map((r) => r.DBClusters?.[0]?.Status ?? "gone"),
108 Effect.catchTag("DBClusterNotFoundFault", () => Effect.succeed("gone" as const)),
109 );
110 if (status !== "gone" && status !== "deleting") {
111 return yield* Effect.fail(
112 new Error(`cluster '${identifier}' still exists (status: ${status})`),
113 );
114 }
115 }).pipe(
116 Effect.retry({ schedule: Schedule.max([Schedule.fixed("10 seconds"), Schedule.recurs(18)]) }),
117 );
118
119 // A Neptune cluster + instance take ~15-30 minutes to provision and bill per
120 // instance-hour while they exist. The full lifecycle is skipped under
121 // `--fast` and always destroys what it created.
122 test.provider.skipIf(!!process.env.FAST)(
123 "create Neptune cluster + serverless instance, verify, destroy",
124 (stack) =>
125 Effect.gen(function* () {
126 yield* stack.destroy();
127
128 const network = yield* defaultNetwork;
129
130 const { cluster, instance } = yield* stack.deploy(
131 Effect.gen(function* () {
132 const subnetGroup = yield* DBSubnetGroup("Subnets", {
133 description: "alchemy neptune cluster subnets",
134 subnetIds: network.subnetIds,
135 });
136 const cluster = yield* DBCluster("Cluster", {
137 dbSubnetGroupName: subnetGroup.dbSubnetGroupName,
138 vpcSecurityGroupIds: network.securityGroupIds,
139 backupRetentionPeriod: "1 day",
140 deletionProtection: false,
141 enableIAMDatabaseAuthentication: true,
142 serverlessV2ScalingConfiguration: { minCapacity: 1, maxCapacity: 2.5 },
143 tags: { fixture: "neptune-cluster" },
144 });
145 const instance = yield* DBInstance("Writer", {
146 dbClusterIdentifier: cluster.dbClusterIdentifier,
147 dbInstanceClass: "db.serverless",
148 tags: { fixture: "neptune-instance" },
149 });
150 return { cluster, instance };
151 }),
152 );
153
154 expect(cluster.dbClusterIdentifier).toBeDefined();
155 expect(cluster.dbClusterArn).toContain(":cluster:");
156 expect(cluster.engine).toBe("neptune");
157 expect(cluster.status).toBe("available");
158 expect(cluster.endpoint).toContain("neptune");
159 expect(cluster.port).toBe(8182);
160 expect(cluster.iamDatabaseAuthenticationEnabled).toBe(true);
161
162 expect(instance.dbInstanceIdentifier).toBeDefined();
163 expect(instance.dbClusterIdentifier).toBe(cluster.dbClusterIdentifier);
164 expect(instance.dbInstanceClass).toBe("db.serverless");
165 expect(instance.status).toBe("available");
166
167 // Out-of-band verification via distilled.
168 const describedCluster = yield* neptune.describeDBClusters({
169 DBClusterIdentifier: cluster.dbClusterIdentifier,
170 });
171 const observedCluster = describedCluster.DBClusters?.[0];
172 expect(observedCluster?.Status).toBe("available");
173 expect(observedCluster?.Engine).toBe("neptune");
174 expect(observedCluster?.DBClusterMembers?.length).toBe(1);
175
176 const describedInstance = yield* neptune.describeDBInstances({
177 DBInstanceIdentifier: instance.dbInstanceIdentifier,
178 });
179 expect(describedInstance.DBInstances?.[0]?.DBInstanceStatus).toBe("available");
180
181 // Destroy immediately — instances bill while they exist — and verify
182 // cluster deletion was initiated out-of-band.
183 yield* stack.destroy();
184 yield* assertClusterDeleting(cluster.dbClusterIdentifier);
185 }),
186 // cluster create (~5-10 min) + serverless instance create (10-20 min) +
187 // instance/cluster delete-until-gone, one test.
188 {
189 tags: ["provider:aws", "provider:aws:ec2", "provider:aws:neptune", "live"],
190 timeout: 2_700_000,
191 },
192 );