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

main
ts 297 lines 10.1 KB
Raw
1 import * as AWS from "@alchemy.run/aws";
2 import { Parameter } from "@alchemy.run/aws/SSM";
3 import { expect } from "@alchemy.run/test";
4 import * as Test from "@alchemy.run/test/Alchemy";
5 import * as ssm from "@distilled.cloud/aws/ssm";
6 import * as Data from "effect/Data";
7 import * as Effect from "effect/Effect";
8 import * as Redacted from "effect/Redacted";
9 import * as Schedule from "effect/Schedule";
10 import { driftOf, repairDrift, waitForDrift } from "../drift.ts";
11
12 const { test } = Test.make({ providers: AWS.providers() });
13
14 const plain = (value: string | Redacted.Redacted<string> | undefined): string | undefined =>
15 value === undefined ? undefined : typeof value === "string" ? value : Redacted.value(value);
16
17 class ParameterStillExists extends Data.TaggedError("ParameterStillExists")<{
18 readonly name: string;
19 }> {}
20
21 const assertParameterDeleted = (name: string) =>
22 ssm.getParameter({ Name: name }).pipe(
23 Effect.flatMap(() => Effect.fail(new ParameterStillExists({ name }))),
24 Effect.catchTag("ParameterNotFound", () => Effect.void),
25 Effect.retry({
26 while: (e) => e._tag === "ParameterStillExists",
27 schedule: Schedule.max([Schedule.exponential(500), Schedule.recurs(8)]),
28 }),
29 );
30
31 test.provider(
32 "create, update value, update tags, delete String parameter",
33 (stack) =>
34 Effect.gen(function* () {
35 // reconcile away any prior partial/crashed deployment
36 yield* stack.destroy();
37
38 const parameter = yield* stack.deploy(
39 Effect.gen(function* () {
40 return yield* Parameter("ConfigParam", {
41 value: "v1",
42 description: "test config value",
43 tags: { Environment: "test" },
44 });
45 }),
46 );
47
48 expect(parameter.parameterName).toBeDefined();
49 expect(parameter.parameterArn).toContain(":parameter/");
50 expect(parameter.type).toBe("String");
51 expect(parameter.version).toBe(1);
52 expect(parameter.keyArn).toBeUndefined();
53
54 // out-of-band verification via distilled
55 const created = yield* ssm.getParameter({
56 Name: parameter.parameterName,
57 });
58 expect(plain(created.Parameter?.Value)).toBe("v1");
59 expect(created.Parameter?.Type).toBe("String");
60
61 // update the value (new version) and add a tag
62 const updated = yield* stack.deploy(
63 Effect.gen(function* () {
64 return yield* Parameter("ConfigParam", {
65 value: "v2",
66 description: "test config value",
67 tags: { Environment: "test", Extra: "1" },
68 });
69 }),
70 );
71 expect(updated.parameterName).toBe(parameter.parameterName);
72 expect(updated.version).toBeGreaterThan(parameter.version);
73
74 const afterUpdate = yield* ssm.getParameter({
75 Name: parameter.parameterName,
76 });
77 expect(plain(afterUpdate.Parameter?.Value)).toBe("v2");
78
79 const tags = yield* ssm.listTagsForResource({
80 ResourceType: "Parameter",
81 ResourceId: parameter.parameterName,
82 });
83 const tagRecord = Object.fromEntries((tags.TagList ?? []).map((t) => [t.Key, t.Value]));
84 expect(tagRecord.Environment).toBe("test");
85 expect(tagRecord.Extra).toBe("1");
86 expect(tagRecord["alchemy::id"]).toBe("ConfigParam");
87
88 // no-op deploy converges without bumping the version
89 const noop = yield* stack.deploy(
90 Effect.gen(function* () {
91 return yield* Parameter("ConfigParam", {
92 value: "v2",
93 description: "test config value",
94 tags: { Environment: "test", Extra: "1" },
95 });
96 }),
97 );
98 expect(noop.version).toBe(updated.version);
99
100 // remove a tag
101 yield* stack.deploy(
102 Effect.gen(function* () {
103 return yield* Parameter("ConfigParam", {
104 value: "v2",
105 description: "test config value",
106 tags: { Environment: "test" },
107 });
108 }),
109 );
110 const afterTagRemoval = yield* ssm.listTagsForResource({
111 ResourceType: "Parameter",
112 ResourceId: parameter.parameterName,
113 });
114 const remaining = Object.fromEntries(
115 (afterTagRemoval.TagList ?? []).map((t) => [t.Key, t.Value]),
116 );
117 expect(remaining.Extra).toBeUndefined();
118 expect(remaining.Environment).toBe("test");
119
120 yield* stack.destroy();
121 yield* assertParameterDeleted(parameter.parameterName);
122 }),
123 { tags: ["provider:aws", "provider:aws:ssm", "live"], timeout: 120_000 },
124 );
125
126 test.provider(
127 "SecureString parameter lifecycle",
128 (stack) =>
129 Effect.gen(function* () {
130 // reconcile away any prior partial/crashed deployment
131 yield* stack.destroy();
132
133 const parameter = yield* stack.deploy(
134 Effect.gen(function* () {
135 return yield* Parameter("SecureParam", {
136 type: "SecureString",
137 value: Redacted.make("super-secret-v1"),
138 });
139 }),
140 );
141
142 expect(parameter.type).toBe("SecureString");
143 expect(parameter.keyArn).toContain(":key/");
144
145 const decrypted = yield* ssm.getParameter({
146 Name: parameter.parameterName,
147 WithDecryption: true,
148 });
149 expect(plain(decrypted.Parameter?.Value)).toBe("super-secret-v1");
150 expect(decrypted.Parameter?.Type).toBe("SecureString");
151
152 // rotate the value
153 const rotated = yield* stack.deploy(
154 Effect.gen(function* () {
155 return yield* Parameter("SecureParam", {
156 type: "SecureString",
157 value: Redacted.make("super-secret-v2"),
158 });
159 }),
160 );
161 expect(rotated.version).toBeGreaterThan(parameter.version);
162 const afterRotate = yield* ssm.getParameter({
163 Name: parameter.parameterName,
164 WithDecryption: true,
165 });
166 expect(plain(afterRotate.Parameter?.Value)).toBe("super-secret-v2");
167
168 yield* stack.destroy();
169 yield* assertParameterDeleted(parameter.parameterName);
170 }),
171 { tags: ["provider:aws", "provider:aws:ssm", "live"], timeout: 120_000 },
172 );
173
174 test.provider(
175 "type change String -> SecureString updates in place",
176 (stack) =>
177 Effect.gen(function* () {
178 // reconcile away any prior partial/crashed deployment
179 yield* stack.destroy();
180
181 const parameter = yield* stack.deploy(
182 Effect.gen(function* () {
183 return yield* Parameter("TypeChangeParam", {
184 value: "plain-value",
185 });
186 }),
187 );
188 expect(parameter.type).toBe("String");
189
190 const upgraded = yield* stack.deploy(
191 Effect.gen(function* () {
192 return yield* Parameter("TypeChangeParam", {
193 type: "SecureString",
194 value: Redacted.make("now-encrypted"),
195 });
196 }),
197 );
198
199 // same physical parameter — updated in place via Overwrite, not replaced
200 expect(upgraded.parameterName).toBe(parameter.parameterName);
201 expect(upgraded.type).toBe("SecureString");
202 expect(upgraded.keyArn).toContain(":key/");
203
204 const observed = yield* ssm.getParameter({
205 Name: parameter.parameterName,
206 WithDecryption: true,
207 });
208 expect(observed.Parameter?.Type).toBe("SecureString");
209 expect(plain(observed.Parameter?.Value)).toBe("now-encrypted");
210
211 yield* stack.destroy();
212 yield* assertParameterDeleted(parameter.parameterName);
213 }),
214 { tags: ["provider:aws", "provider:aws:ssm", "live"], timeout: 120_000 },
215 );
216
217 test.provider(
218 "custom hierarchical name and replacement on rename",
219 (stack) =>
220 Effect.gen(function* () {
221 // reconcile away any prior partial/crashed deployment
222 yield* stack.destroy();
223
224 const first = yield* stack.deploy(
225 Effect.gen(function* () {
226 return yield* Parameter("PathParam", {
227 name: "/alchemy-test/ssm/path-param-a",
228 value: "a",
229 });
230 }),
231 );
232 expect(first.parameterName).toBe("/alchemy-test/ssm/path-param-a");
233 expect(first.parameterArn).toContain(":parameter/alchemy-test/ssm/path-param-a");
234
235 // renaming triggers a replacement: new physical parameter, old one gone
236 const second = yield* stack.deploy(
237 Effect.gen(function* () {
238 return yield* Parameter("PathParam", {
239 name: "/alchemy-test/ssm/path-param-b",
240 value: "b",
241 });
242 }),
243 );
244 expect(second.parameterName).toBe("/alchemy-test/ssm/path-param-b");
245
246 const observed = yield* ssm.getParameter({
247 Name: "/alchemy-test/ssm/path-param-b",
248 });
249 expect(plain(observed.Parameter?.Value)).toBe("b");
250 yield* assertParameterDeleted("/alchemy-test/ssm/path-param-a");
251
252 yield* stack.destroy();
253 yield* assertParameterDeleted("/alchemy-test/ssm/path-param-b");
254 }),
255 { tags: ["provider:aws", "provider:aws:ssm", "live"], timeout: 120_000 },
256 );
257
258 // #2688: `read` must observe the declared description and the tags, or an
259 // out-of-band change reads as `unchanged`.
260 test.provider(
261 "drift detects and repairs out-of-band parameter metadata and tags",
262 (stack) =>
263 Effect.gen(function* () {
264 yield* stack.destroy();
265
266 const param = yield* stack.deploy(
267 Parameter("DriftParam", {
268 value: "declared",
269 description: "declared",
270 tags: { team: "declared" },
271 }),
272 );
273 expect((yield* driftOf(stack, "DriftParam"))?.action).toBe("unchanged");
274
275 yield* ssm.addTagsToResource({
276 ResourceType: "Parameter",
277 ResourceId: param.parameterName,
278 Tags: [{ Key: "team", Value: "out-of-band" }],
279 });
280
281 const drifted = yield* waitForDrift(stack, "DriftParam", "drifted");
282 expect(drifted?.attr?.configuration?.tags?.team).toBe("out-of-band");
283
284 const repaired = yield* repairDrift(stack);
285 expect(repaired.resources.DriftParam?.action).toBe("repaired");
286 expect((yield* driftOf(stack, "DriftParam"))?.action).toBe("unchanged");
287 const tags = yield* ssm.listTagsForResource({
288 ResourceType: "Parameter",
289 ResourceId: param.parameterName,
290 });
291 expect(tags.TagList?.find((t) => t.Key === "team")?.Value).toBe("declared");
292
293 yield* stack.destroy();
294 yield* assertParameterDeleted(param.parameterName);
295 }),
296 { tags: ["provider:aws", "provider:aws:ssm", "live"] },
297 );