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

main
ts 274 lines 10.1 KB
Raw
1 import * as AWS from "@alchemy.run/aws";
2 import { DataSet, EventAction, Revision } from "@alchemy.run/aws/DataExchange";
3 import { toTagRecord } from "@alchemy.run/aws/DataExchange/internal";
4 import { expect } from "@alchemy.run/test";
5 import * as Test from "@alchemy.run/test/Alchemy";
6 import * as dataexchange from "@distilled.cloud/aws/dataexchange";
7 import * as Effect from "effect/Effect";
8
9 const { test } = Test.make({ providers: AWS.providers() });
10
11 // Typed-error probe: proves the SDK decodes DataExchange errors as typed
12 // tags. A missing data set surfaces as ResourceNotFoundException.
13 test.provider(
14 "getDataSet on a nonexistent id fails with a typed error",
15 () =>
16 Effect.gen(function* () {
17 const error = yield* Effect.flip(
18 dataexchange.getDataSet({
19 DataSetId: "ffffffffffffffffffffffffffffffff",
20 }),
21 );
22 expect(error._tag).toBe("ResourceNotFoundException");
23 }),
24 { tags: ["provider:aws", "provider:aws:dataexchange", "live"] },
25 );
26
27 // Data sets and revisions are cheap, instant metadata objects — the live
28 // lifecycle runs ungated with out-of-band verification. Asset import jobs
29 // (the paid/slow part) are out of scope for the definition lifecycle.
30 test.provider(
31 "create, update, destroy a data set with a revision",
32 (stack) =>
33 Effect.gen(function* () {
34 yield* stack.destroy();
35
36 const created = yield* stack.deploy(
37 Effect.gen(function* () {
38 const dataSet = yield* DataSet("Prices", {
39 description: "Daily commodity price snapshots",
40 tags: { Environment: "test" },
41 });
42 const revision = yield* Revision("PricesV1", {
43 dataSetId: dataSet.dataSetId,
44 comment: "Initial snapshot",
45 tags: { Environment: "test" },
46 });
47 return { dataSet, revision };
48 }),
49 );
50
51 expect(created.dataSet.dataSetArn).toContain(":data-sets/");
52 expect(created.dataSet.assetType).toBe("S3_SNAPSHOT");
53 expect(created.dataSet.origin).toBe("OWNED");
54 expect(created.revision.revisionArn).toContain("/revisions/");
55 expect(created.revision.dataSetId).toBe(created.dataSet.dataSetId);
56 expect(created.revision.finalized).toBe(false);
57
58 // Out-of-band verification via distilled.
59 const observed = yield* dataexchange.getDataSet({
60 DataSetId: created.dataSet.dataSetId,
61 });
62 expect(observed.Name).toBe(created.dataSet.name);
63 expect(observed.Description).toBe("Daily commodity price snapshots");
64 const dataSetTags = yield* dataexchange.listTagsForResource({
65 ResourceArn: created.dataSet.dataSetArn,
66 });
67 expect(toTagRecord(dataSetTags.Tags)["alchemy::id"]).toBe("Prices");
68 expect(toTagRecord(dataSetTags.Tags).Environment).toBe("test");
69
70 const observedRevision = yield* dataexchange.getRevision({
71 DataSetId: created.dataSet.dataSetId,
72 RevisionId: created.revision.revisionId,
73 });
74 expect(observedRevision.Comment).toBe("Initial snapshot");
75 const revisionTags = yield* dataexchange.listTagsForResource({
76 ResourceArn: created.revision.revisionArn,
77 });
78 expect(toTagRecord(revisionTags.Tags)["alchemy::id"]).toBe("PricesV1");
79
80 // Update in place: description, revision comment, and tags.
81 const updated = yield* stack.deploy(
82 Effect.gen(function* () {
83 const dataSet = yield* DataSet("Prices", {
84 description: "Hourly commodity price snapshots",
85 tags: { Environment: "test", Extra: "yes" },
86 });
87 const revision = yield* Revision("PricesV1", {
88 dataSetId: dataSet.dataSetId,
89 comment: "Amended snapshot",
90 });
91 return { dataSet, revision };
92 }),
93 );
94
95 // Stable identifiers are preserved across the update.
96 expect(updated.dataSet.dataSetId).toBe(created.dataSet.dataSetId);
97 expect(updated.revision.revisionId).toBe(created.revision.revisionId);
98
99 const reobserved = yield* dataexchange.getDataSet({
100 DataSetId: created.dataSet.dataSetId,
101 });
102 expect(reobserved.Description).toBe("Hourly commodity price snapshots");
103 const updatedTags = yield* dataexchange.listTagsForResource({
104 ResourceArn: created.dataSet.dataSetArn,
105 });
106 expect(toTagRecord(updatedTags.Tags).Extra).toBe("yes");
107
108 const reobservedRevision = yield* dataexchange.getRevision({
109 DataSetId: created.dataSet.dataSetId,
110 RevisionId: created.revision.revisionId,
111 });
112 expect(reobservedRevision.Comment).toBe("Amended snapshot");
113 // User tag was removed from the revision; internal tags survive.
114 const updatedRevisionTags = yield* dataexchange.listTagsForResource({
115 ResourceArn: created.revision.revisionArn,
116 });
117 expect(toTagRecord(updatedRevisionTags.Tags).Environment).toBeUndefined();
118 expect(toTagRecord(updatedRevisionTags.Tags)["alchemy::id"]).toBe("PricesV1");
119
120 // Destroy and verify deletion out-of-band.
121 yield* stack.destroy();
122 const dataSetError = yield* Effect.flip(
123 dataexchange.getDataSet({ DataSetId: created.dataSet.dataSetId }),
124 );
125 expect(dataSetError._tag).toBe("ResourceNotFoundException");
126 }),
127 {
128 tags: ["provider:aws", "provider:aws:dataexchange", "live"],
129 timeout: 300_000,
130 },
131 );
132
133 // Replacement: assetType is immutable, so changing it replaces the data set.
134 test.provider(
135 "changing assetType replaces the data set",
136 (stack) =>
137 Effect.gen(function* () {
138 yield* stack.destroy();
139
140 const created = yield* stack.deploy(
141 Effect.gen(function* () {
142 return yield* DataSet("Replaceable", {
143 assetType: "S3_SNAPSHOT",
144 description: "before replacement",
145 });
146 }),
147 );
148 expect(created.assetType).toBe("S3_SNAPSHOT");
149
150 const replaced = yield* stack.deploy(
151 Effect.gen(function* () {
152 return yield* DataSet("Replaceable", {
153 assetType: "API_GATEWAY_API",
154 description: "after replacement",
155 });
156 }),
157 );
158 expect(replaced.assetType).toBe("API_GATEWAY_API");
159 expect(replaced.dataSetId).not.toBe(created.dataSetId);
160
161 // The old data set is gone.
162 const oldError = yield* Effect.flip(
163 dataexchange.getDataSet({ DataSetId: created.dataSetId }),
164 );
165 expect(oldError._tag).toBe("ResourceNotFoundException");
166
167 yield* stack.destroy();
168 const newError = yield* Effect.flip(
169 dataexchange.getDataSet({ DataSetId: replaced.dataSetId }),
170 );
171 expect(newError._tag).toBe("ResourceNotFoundException");
172 }),
173 {
174 tags: ["provider:aws", "provider:aws:dataexchange", "live"],
175 timeout: 300_000,
176 },
177 );
178
179 // Event actions only attach to ENTITLED data sets (subscriptions / accepted
180 // data grants), which cannot be provisioned self-contained. This ungated
181 // probe proves the rejection against an OWNED data set is a typed tag.
182 test.provider(
183 "createEventAction against an owned data set fails with a typed error",
184 () =>
185 Effect.gen(function* () {
186 const dataSet = yield* dataexchange.createDataSet({
187 AssetType: "S3_SNAPSHOT",
188 Name: "alchemy-test-dataexchange-eventaction-probe",
189 Description: "event action entitlement probe",
190 });
191 const error = yield* Effect.flip(
192 dataexchange.createEventAction({
193 Action: {
194 ExportRevisionToS3: {
195 RevisionDestination: { Bucket: "alchemy-nonexistent-bucket" },
196 },
197 },
198 Event: { RevisionPublished: { DataSetId: dataSet.Id! } },
199 }),
200 ).pipe(
201 Effect.ensuring(
202 // Cleanup tolerates ONLY the typed not-found; any other delete
203 // failure must surface rather than silently orphan the data set.
204 dataexchange.deleteDataSet({ DataSetId: dataSet.Id! }).pipe(
205 Effect.catchTag("ResourceNotFoundException", () => Effect.void),
206 Effect.orDie,
207 ),
208 ),
209 );
210 expect(error._tag).toBe("ValidationException");
211 }),
212 {
213 tags: ["provider:aws", "provider:aws:dataexchange", "live"],
214 timeout: 60_000,
215 },
216 );
217
218 // Full event-action lifecycle needs an entitled data set — run it from an
219 // account with an active subscription/data grant by setting
220 // AWS_TEST_DATAEXCHANGE_ENTITLED_DATASET_ID (and an export bucket whose
221 // policy admits dataexchange.amazonaws.com via
222 // AWS_TEST_DATAEXCHANGE_EXPORT_BUCKET).
223 test.provider.skipIf(!process.env.AWS_TEST_DATAEXCHANGE_ENTITLED_DATASET_ID)(
224 "create, update, destroy an event action on an entitled data set",
225 (stack) =>
226 Effect.gen(function* () {
227 const entitledDataSetId = process.env.AWS_TEST_DATAEXCHANGE_ENTITLED_DATASET_ID!;
228 const exportBucket = process.env.AWS_TEST_DATAEXCHANGE_EXPORT_BUCKET!;
229 yield* stack.destroy();
230
231 const created = yield* stack.deploy(
232 Effect.gen(function* () {
233 return yield* EventAction("AutoExport", {
234 dataSetId: entitledDataSetId,
235 exportRevisionToS3: { bucket: exportBucket },
236 });
237 }),
238 );
239 expect(created.eventActionArn).toContain(":event-actions/");
240
241 // Update the key pattern in place.
242 const updated = yield* stack.deploy(
243 Effect.gen(function* () {
244 return yield* EventAction("AutoExport", {
245 dataSetId: entitledDataSetId,
246 exportRevisionToS3: {
247 bucket: exportBucket,
248 keyPattern: "exports/${Revision.CreatedAt}/${Asset.Name}",
249 },
250 });
251 }),
252 );
253 expect(updated.eventActionId).toBe(created.eventActionId);
254
255 const observed = yield* dataexchange.getEventAction({
256 EventActionId: created.eventActionId,
257 });
258 expect(observed.Action?.ExportRevisionToS3?.RevisionDestination.KeyPattern).toBe(
259 "exports/${Revision.CreatedAt}/${Asset.Name}",
260 );
261
262 yield* stack.destroy();
263 const gone = yield* Effect.flip(
264 dataexchange.getEventAction({
265 EventActionId: created.eventActionId,
266 }),
267 );
268 expect(gone._tag).toBe("ResourceNotFoundException");
269 }),
270 {
271 tags: ["provider:aws", "provider:aws:dataexchange", "live"],
272 timeout: 300_000,
273 },
274 );