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

main
ts 97 lines 3.63 KB
Raw
1 import * as AWS from "@alchemy.run/aws";
2 import { PrivateDnsNamespace } from "@alchemy.run/aws/CloudMap";
3 import { expect } from "@alchemy.run/test";
4 import * as Test from "@alchemy.run/test/Alchemy";
5 import * as sd from "@distilled.cloud/aws/servicediscovery";
6 import * as Data from "effect/Data";
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 const findNamespace = (namespaceId: string) =>
14 sd.getNamespace({ Id: namespaceId }).pipe(
15 Effect.map((r) => r.Namespace),
16 Effect.catchTag("NamespaceNotFound", () => Effect.succeed(undefined)),
17 );
18
19 class NamespaceStillExists extends Data.TaggedError("NamespaceStillExists")<{
20 readonly namespaceId: string;
21 }> {}
22
23 const assertNamespaceDeleted = (namespaceId: string) =>
24 findNamespace(namespaceId).pipe(
25 Effect.flatMap((namespace) =>
26 namespace === undefined
27 ? Effect.void
28 : Effect.fail(new NamespaceStillExists({ namespaceId })),
29 ),
30 Effect.retry({
31 while: (e) => e._tag === "NamespaceStillExists",
32 schedule: Schedule.max([Schedule.spaced("3 seconds"), Schedule.recurs(20)]),
33 }),
34 );
35
36 test.provider(
37 "create, update description + SOA TTL, delete private DNS namespace",
38 (stack) =>
39 Effect.gen(function* () {
40 yield* stack.destroy();
41 const vpc = yield* getDefaultVpc;
42
43 const namespace = yield* stack.deploy(
44 Effect.gen(function* () {
45 return yield* PrivateDnsNamespace("TestPrivateNamespace", {
46 name: "alchemy-test-cloudmap-private.local",
47 vpc: vpc.vpcId,
48 description: "initial description",
49 ttl: "60 seconds",
50 tags: { Environment: "test" },
51 });
52 }),
53 );
54
55 expect(namespace.namespaceId).toBeDefined();
56 expect(namespace.namespaceArn).toContain(":namespace/");
57 expect(namespace.namespaceName).toBe("alchemy-test-cloudmap-private.local");
58 // a private DNS namespace creates a Route 53 private hosted zone
59 expect(namespace.hostedZoneId).toBeDefined();
60
61 // out-of-band verification via distilled
62 const created = yield* findNamespace(namespace.namespaceId);
63 expect(created?.Type).toBe("DNS_PRIVATE");
64 expect(created?.Description).toBe("initial description");
65 expect(created?.Properties?.DnsProperties?.SOA?.TTL).toBe(60);
66 const tags = yield* sd
67 .listTagsForResource({ ResourceARN: namespace.namespaceArn })
68 .pipe(Effect.map((r) => Object.fromEntries((r.Tags ?? []).map((t) => [t.Key, t.Value]))));
69 expect(tags.Environment).toBe("test");
70 expect(tags["alchemy::id"]).toBe("TestPrivateNamespace");
71
72 // update description + SOA TTL (async namespace update operation)
73 const updated = yield* stack.deploy(
74 Effect.gen(function* () {
75 return yield* PrivateDnsNamespace("TestPrivateNamespace", {
76 name: "alchemy-test-cloudmap-private.local",
77 vpc: vpc.vpcId,
78 description: "updated description",
79 ttl: "120 seconds",
80 tags: { Environment: "test" },
81 });
82 }),
83 );
84 expect(updated.namespaceId).toBe(namespace.namespaceId);
85
86 const afterUpdate = yield* findNamespace(namespace.namespaceId);
87 expect(afterUpdate?.Description).toBe("updated description");
88 expect(afterUpdate?.Properties?.DnsProperties?.SOA?.TTL).toBe(120);
89
90 yield* stack.destroy();
91 yield* assertNamespaceDeleted(namespace.namespaceId);
92 }),
93 {
94 tags: ["provider:aws", "provider:aws:cloudmap", "provider:aws:ec2", "live"],
95 timeout: 240_000,
96 },
97 );