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

main
ts 148 lines 5.04 KB
Raw
1 import * as AWS from "@alchemy.run/aws";
2 import { Stream } from "@alchemy.run/aws/KinesisVideo";
3 import { expect } from "@alchemy.run/test";
4 import * as Test from "@alchemy.run/test/Alchemy";
5 import * as kv from "@distilled.cloud/aws/kinesis-video";
6 import * as Data from "effect/Data";
7 import * as Effect from "effect/Effect";
8 import * as Schedule from "effect/Schedule";
9
10 const { test } = Test.make({ providers: AWS.providers() });
11
12 const findStream = (streamName: string) =>
13 kv.describeStream({ StreamName: streamName }).pipe(
14 Effect.map((r) => r.StreamInfo),
15 Effect.catchTag("ResourceNotFoundException", () => Effect.succeed(undefined)),
16 );
17
18 class StreamStillExists extends Data.TaggedError("StreamStillExists")<{
19 readonly streamName: string;
20 }> {}
21
22 // DeleteStream is asynchronous: the stream lingers in DELETING (data already
23 // inaccessible) for a while — treat DELETING as deleted.
24 const assertStreamDeleted = (streamName: string) =>
25 findStream(streamName).pipe(
26 Effect.flatMap((info) =>
27 info === undefined || info.Status === "DELETING"
28 ? Effect.void
29 : Effect.fail(new StreamStillExists({ streamName })),
30 ),
31 Effect.retry({
32 while: (e) => e._tag === "StreamStillExists",
33 schedule: Schedule.max([Schedule.spaced("3 seconds"), Schedule.recurs(20)]),
34 }),
35 );
36
37 const fetchTags = (streamArn: string) =>
38 kv.listTagsForStream({ StreamARN: streamArn }).pipe(Effect.map((r) => r.Tags ?? {}));
39
40 test.provider(
41 "create, update retention/mediaType/tags, delete video stream",
42 (stack) =>
43 Effect.gen(function* () {
44 yield* stack.destroy();
45
46 const stream = yield* stack.deploy(
47 Effect.gen(function* () {
48 return yield* Stream("TestVideoStream", {
49 dataRetention: "24 hours",
50 tags: { Environment: "test" },
51 });
52 }),
53 );
54
55 expect(stream.streamName).toBeDefined();
56 expect(stream.streamArn).toContain(":stream/");
57
58 // out-of-band verification via distilled
59 const created = yield* findStream(stream.streamName);
60 expect(created?.Status).toBe("ACTIVE");
61 expect(created?.DataRetentionInHours).toBe(24);
62 const tags = yield* fetchTags(stream.streamArn);
63 expect(tags.Environment).toBe("test");
64 expect(tags["alchemy::id"]).toBe("TestVideoStream");
65
66 // update: increase retention, set mediaType + deviceName, extra tag
67 const updated = yield* stack.deploy(
68 Effect.gen(function* () {
69 return yield* Stream("TestVideoStream", {
70 dataRetention: "48 hours",
71 mediaType: "video/h264",
72 deviceName: "camera-1",
73 tags: { Environment: "test", Extra: "yes" },
74 });
75 }),
76 );
77 expect(updated.streamName).toBe(stream.streamName);
78 expect(updated.streamArn).toBe(stream.streamArn);
79
80 const afterUpdate = yield* findStream(stream.streamName);
81 expect(afterUpdate?.DataRetentionInHours).toBe(48);
82 expect(afterUpdate?.MediaType).toBe("video/h264");
83 expect(afterUpdate?.DeviceName).toBe("camera-1");
84 const tagsAfter = yield* fetchTags(stream.streamArn);
85 expect(tagsAfter.Extra).toBe("yes");
86
87 // decrease retention back down (DECREASE_DATA_RETENTION path)
88 const decreased = yield* stack.deploy(
89 Effect.gen(function* () {
90 return yield* Stream("TestVideoStream", {
91 dataRetention: "24 hours",
92 mediaType: "video/h264",
93 deviceName: "camera-1",
94 tags: { Environment: "test" },
95 });
96 }),
97 );
98 expect(decreased.streamArn).toBe(stream.streamArn);
99 const afterDecrease = yield* findStream(stream.streamName);
100 expect(afterDecrease?.DataRetentionInHours).toBe(24);
101 const tagsAfterRemoval = yield* fetchTags(stream.streamArn);
102 expect(tagsAfterRemoval.Extra).toBeUndefined();
103
104 yield* stack.destroy();
105 yield* assertStreamDeleted(stream.streamName);
106 }),
107 {
108 tags: ["provider:aws", "provider:aws:kinesisvideo", "live"],
109 timeout: 240_000,
110 },
111 );
112
113 test.provider(
114 "explicit name and replacement on rename",
115 (stack) =>
116 Effect.gen(function* () {
117 yield* stack.destroy();
118
119 const first = yield* stack.deploy(
120 Effect.gen(function* () {
121 return yield* Stream("NamedVideoStream", {
122 streamName: "alchemy-test-kvs-stream-a",
123 });
124 }),
125 );
126 expect(first.streamName).toBe("alchemy-test-kvs-stream-a");
127
128 // renaming triggers a replacement: new physical stream, old gone
129 const second = yield* stack.deploy(
130 Effect.gen(function* () {
131 return yield* Stream("NamedVideoStream", {
132 streamName: "alchemy-test-kvs-stream-b",
133 });
134 }),
135 );
136 expect(second.streamName).toBe("alchemy-test-kvs-stream-b");
137 expect(second.streamArn).not.toBe(first.streamArn);
138
139 yield* assertStreamDeleted(first.streamName);
140
141 yield* stack.destroy();
142 yield* assertStreamDeleted(second.streamName);
143 }),
144 {
145 tags: ["provider:aws", "provider:aws:kinesisvideo", "live"],
146 timeout: 240_000,
147 },
148 );