@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 143 lines 4.85 KB
Raw
1 import * as AWS from "@alchemy.run/aws";
2 import { Dataset } from "@alchemy.run/aws/DataBrew";
3 import { Bucket } from "@alchemy.run/aws/S3";
4 import { expect } from "@alchemy.run/test";
5 import * as Test from "@alchemy.run/test/Alchemy";
6 import * as databrew from "@distilled.cloud/aws/databrew";
7 import * as Effect from "effect/Effect";
8
9 const { test } = Test.make({ providers: AWS.providers() });
10
11 const getDataset = (name: string) =>
12 databrew
13 .describeDataset({ Name: name })
14 .pipe(Effect.catchTag("ResourceNotFoundException", () => Effect.succeed(undefined)));
15
16 test.provider(
17 "create, update, delete DataBrew dataset",
18 (stack) =>
19 Effect.gen(function* () {
20 yield* stack.destroy();
21
22 const created = yield* stack.deploy(
23 Effect.gen(function* () {
24 const bucket = yield* Bucket("DataBucket", { forceDestroy: true });
25 const dataset = yield* Dataset("Sales", {
26 format: "CSV",
27 formatOptions: { csv: { delimiter: ",", headerRow: true } },
28 input: {
29 s3InputDefinition: {
30 bucket: bucket.bucketName,
31 key: "raw/sales.csv",
32 },
33 },
34 tags: { Environment: "test" },
35 });
36 return { bucket, dataset };
37 }),
38 );
39
40 expect(created.dataset.datasetName).toBeDefined();
41 expect(created.dataset.datasetArn).toContain(`:dataset/${created.dataset.datasetName}`);
42
43 // out-of-band verification
44 const observed = yield* getDataset(created.dataset.datasetName);
45 expect(observed?.Name).toEqual(created.dataset.datasetName);
46 expect(observed?.Format).toEqual("CSV");
47 expect(observed?.Input.S3InputDefinition?.Bucket).toEqual(created.bucket.bucketName);
48 expect(observed?.Input.S3InputDefinition?.Key).toEqual("raw/sales.csv");
49 expect(observed?.FormatOptions?.Csv?.Delimiter).toEqual(",");
50 expect(observed?.Tags?.["alchemy::id"]).toBeDefined();
51 expect(observed?.Tags?.Environment).toEqual("test");
52
53 // update: different key + delimiter + tag change
54 yield* stack.deploy(
55 Effect.gen(function* () {
56 const bucket = yield* Bucket("DataBucket", { forceDestroy: true });
57 const dataset = yield* Dataset("Sales", {
58 format: "CSV",
59 formatOptions: { csv: { delimiter: ";", headerRow: false } },
60 input: {
61 s3InputDefinition: {
62 bucket: bucket.bucketName,
63 key: "raw/sales-v2.csv",
64 },
65 },
66 tags: { Environment: "staging" },
67 });
68 return { dataset };
69 }),
70 );
71
72 const reobserved = yield* getDataset(created.dataset.datasetName);
73 expect(reobserved?.Input.S3InputDefinition?.Key).toEqual("raw/sales-v2.csv");
74 expect(reobserved?.FormatOptions?.Csv?.Delimiter).toEqual(";");
75 expect(reobserved?.Tags?.Environment).toEqual("staging");
76
77 yield* stack.destroy();
78 const gone = yield* getDataset(created.dataset.datasetName);
79 expect(gone).toBeUndefined();
80 }),
81 {
82 tags: ["provider:aws", "provider:aws:databrew", "provider:aws:s3", "live"],
83 timeout: 120_000,
84 },
85 );
86
87 test.provider(
88 "changing the dataset name replaces the dataset",
89 (stack) =>
90 Effect.gen(function* () {
91 yield* stack.destroy();
92
93 const nameA = "alchemy-test-databrew-dataset-a";
94 const nameB = "alchemy-test-databrew-dataset-b";
95
96 const first = yield* stack.deploy(
97 Effect.gen(function* () {
98 const bucket = yield* Bucket("DataBucket", { forceDestroy: true });
99 const dataset = yield* Dataset("Named", {
100 datasetName: nameA,
101 format: "CSV",
102 input: {
103 s3InputDefinition: {
104 bucket: bucket.bucketName,
105 key: "raw/data.csv",
106 },
107 },
108 });
109 return { bucket, dataset };
110 }),
111 );
112 expect(first.dataset.datasetName).toEqual(nameA);
113
114 const second = yield* stack.deploy(
115 Effect.gen(function* () {
116 const bucket = yield* Bucket("DataBucket", { forceDestroy: true });
117 const dataset = yield* Dataset("Named", {
118 datasetName: nameB,
119 format: "CSV",
120 input: {
121 s3InputDefinition: {
122 bucket: bucket.bucketName,
123 key: "raw/data.csv",
124 },
125 },
126 });
127 return { dataset };
128 }),
129 );
130 expect(second.dataset.datasetName).toEqual(nameB);
131
132 // the old dataset is gone, the new one exists
133 expect(yield* getDataset(nameA)).toBeUndefined();
134 expect((yield* getDataset(nameB))?.Name).toEqual(nameB);
135
136 yield* stack.destroy();
137 expect(yield* getDataset(nameB)).toBeUndefined();
138 }),
139 {
140 tags: ["provider:aws", "provider:aws:databrew", "provider:aws:s3", "live"],
141 timeout: 120_000,
142 },
143 );