@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 638 lines 25.9 KB
Raw
1 import * as AWS from "@alchemy.run/aws";
2 import { DBParameterGroup } from "@alchemy.run/aws/RDS/DBParameterGroup";
3 import { expect } from "@alchemy.run/test";
4 import * as Test from "@alchemy.run/test/Alchemy";
5 import * as rds from "@distilled.cloud/aws/rds";
6 import * as Drift from "alchemy/Drift";
7 import * as Provider from "alchemy/Provider";
8 import * as Effect from "effect/Effect";
9 import * as Schedule from "effect/Schedule";
10 import * as Stream from "effect/Stream";
11
12 const { test } = Test.make({ providers: AWS.providers() });
13
14 /** The parameters RDS reports as user-set, which is what the resource owns. */
15 const userParameters = Effect.fn(function* (name: string) {
16 const pages = yield* rds.describeDBParameters
17 .pages({ DBParameterGroupName: name, Source: "user" })
18 .pipe(Stream.runCollect);
19 return Object.fromEntries(
20 Array.from(pages)
21 .flatMap((page) => page.Parameters ?? [])
22 .flatMap((p) =>
23 p.ParameterName && p.ParameterValue !== undefined
24 ? [[p.ParameterName, p.ParameterValue] as const]
25 : [],
26 ),
27 );
28 });
29
30 const groupParameters = Effect.fn(function* (name: string) {
31 const pages = yield* rds.describeDBParameters
32 .pages({ DBParameterGroupName: name })
33 .pipe(Stream.runCollect);
34 return new Map(
35 Array.from(pages).flatMap((page) =>
36 (page.Parameters ?? []).flatMap((parameter) =>
37 parameter.ParameterName === undefined
38 ? []
39 : [[parameter.ParameterName, parameter] as const],
40 ),
41 ),
42 );
43 });
44
45 const waitForParameters = Effect.fn(function* (
46 name: string,
47 ready: (parameters: Map<string, rds.Parameter>) => boolean,
48 ) {
49 const parameters = yield* groupParameters(name).pipe(
50 Effect.repeat({ schedule: Schedule.spaced("3 seconds"), times: 8, until: ready }),
51 );
52 expect(ready(parameters)).toBe(true);
53 return parameters;
54 });
55
56 const modifyParameters = (name: string, parameters: rds.Parameter[]) =>
57 rds.modifyDBParameterGroup({ DBParameterGroupName: name, Parameters: parameters }).pipe(
58 Effect.retry({
59 while: (error) => error._tag === "InvalidDBParameterGroupStateFault",
60 schedule: Schedule.spaced("3 seconds"),
61 times: 8,
62 }),
63 );
64
65 const resetParameters = (name: string, parameters: rds.Parameter[]) =>
66 rds
67 .resetDBParameterGroup({
68 DBParameterGroupName: name,
69 ResetAllParameters: false,
70 Parameters: parameters,
71 })
72 .pipe(
73 Effect.retry({
74 while: (error) => error._tag === "InvalidDBParameterGroupStateFault",
75 schedule: Schedule.spaced("3 seconds"),
76 times: 8,
77 }),
78 );
79
80 const assertGroupGone = Effect.fn(function* (name: string) {
81 const gone = yield* rds.describeDBParameterGroups({ DBParameterGroupName: name }).pipe(
82 Effect.as(false),
83 Effect.catchTag("DBParameterGroupNotFoundFault", () => Effect.succeed(true)),
84 Effect.repeat({ schedule: Schedule.spaced("3 seconds"), times: 8, until: (gone) => gone }),
85 );
86 expect(gone).toBe(true);
87 });
88
89 // Canonical `list()` test (AWS account/region-scoped collection). Parameter
90 // groups create and delete fast (well within the 240s budget), so we deploy a
91 // real group, resolve the provider via the typed `Provider.findProvider(
92 // DBParameterGroup)` so `list()`'s element type is the exact
93 // `DBParameterGroup["Attributes"]` shape, call it, and assert the deployed
94 // group appears in the exhaustively-paginated result.
95 test.provider(
96 "list enumerates the deployed DB parameter group",
97 (stack) =>
98 Effect.gen(function* () {
99 yield* stack.destroy();
100
101 const group = yield* stack.deploy(
102 Effect.gen(function* () {
103 return yield* DBParameterGroup("ListDBParameterGroup", {
104 dbParameterGroupName: "alchemy-test-dbpg-list",
105 family: "aurora-postgresql16",
106 description: "Alchemy list() test parameter group",
107 });
108 }),
109 );
110
111 const provider = yield* Provider.findProvider(DBParameterGroup);
112 const all = yield* provider.list();
113
114 expect(Array.isArray(all)).toBe(true);
115 expect(all.some((g) => g.dbParameterGroupName === group.dbParameterGroupName)).toBe(true);
116
117 for (const g of all) {
118 expect(typeof g.dbParameterGroupName).toBe("string");
119 expect(typeof g.family).toBe("string");
120 }
121
122 yield* stack.destroy();
123 }),
124 { tags: ["provider:aws", "provider:aws:rds", "live"] },
125 );
126
127 // Parameters reconcile in place: a redeploy writes changed values and resets
128 // keys the props dropped, both diffed against live `Source=user` state rather
129 // than the prior props.
130 test.provider(
131 "parameters are written, updated and reset",
132 (stack) =>
133 Effect.gen(function* () {
134 yield* stack.destroy();
135
136 const name = "alchemy-test-dbpg-params";
137 const deploy = (parameters: Record<string, string>) =>
138 stack.deploy(
139 Effect.gen(function* () {
140 return yield* DBParameterGroup("ParamsDBParameterGroup", {
141 dbParameterGroupName: name,
142 family: "mysql8.4",
143 description: "Alchemy parameters test parameter group",
144 parameters,
145 });
146 }),
147 );
148
149 const created = yield* deploy({ time_zone: "Australia/Sydney", max_connections: "150" });
150 expect(created.parameters.time_zone).toBe("Australia/Sydney");
151
152 const afterCreate = yield* userParameters(name);
153 expect(afterCreate.time_zone).toBe("Australia/Sydney");
154 expect(afterCreate.max_connections).toBe("150");
155
156 // time_zone changes; max_connections is dropped and must go back to the
157 // engine default, which removes it from Source=user entirely.
158 yield* deploy({ time_zone: "UTC" });
159
160 const afterUpdate = yield* userParameters(name);
161 expect(afterUpdate.time_zone).toBe("UTC");
162 expect(afterUpdate.max_connections).toBeUndefined();
163
164 yield* stack.destroy();
165 }),
166 { tags: ["provider:aws", "provider:aws:rds", "live"] },
167 );
168
169 test.provider(
170 "PR1589 adoption resets undeclared overrides to the same defaults as creation",
171 (stack) =>
172 Effect.gen(function* () {
173 yield* stack.destroy();
174 const name = "alchemy-test-pr1589-adopt-parameters";
175 yield* rds.createDBParameterGroup({
176 DBParameterGroupName: name,
177 DBParameterGroupFamily: "postgres16",
178 Description: "Desired-state adoption regression",
179 });
180 yield* modifyParameters(name, [
181 { ParameterName: "work_mem", ParameterValue: "8192", ApplyMethod: "immediate" },
182 ]);
183 yield* waitForParameters(
184 name,
185 (parameters) => parameters.get("work_mem")?.ParameterValue === "8192",
186 );
187 const program = DBParameterGroup("AdoptedParameters1589", {
188 dbParameterGroupName: name,
189 family: "postgres16",
190 description: "Desired-state adoption regression",
191 });
192 const adopted = yield* stack.deploy(program);
193 expect(adopted.parameters).toEqual({});
194 expect(yield* userParameters(name)).toEqual({});
195 expect((yield* stack.plan(program)).resources.AdoptedParameters1589?.action).toBe("noop");
196 yield* stack.destroy();
197 yield* assertGroupGone(name);
198 }),
199 { tags: ["provider:aws", "provider:aws:rds", "live"], timeout: 120_000 },
200 );
201
202 test.provider(
203 "PR1589 resets omitted overrides and observes settled modify/reset outputs",
204 (stack) =>
205 Effect.gen(function* () {
206 yield* stack.destroy();
207 const program = (parameters?: Record<string, string>) =>
208 DBParameterGroup("ObservedParameters1589", { family: "postgres16", parameters });
209 const created = yield* stack.deploy(program());
210 const name = created.dbParameterGroupName;
211 const defaults = yield* groupParameters(name);
212 expect(defaults.get("max_connections")?.ApplyType).toBe("static");
213 expect(defaults.get("work_mem")?.ApplyType).toBe("dynamic");
214
215 yield* modifyParameters(name, [
216 { ParameterName: "work_mem", ParameterValue: "8192", ApplyMethod: "immediate" },
217 { ParameterName: "max_connections", ParameterValue: "200", ApplyMethod: "pending-reboot" },
218 ]);
219 yield* waitForParameters(
220 name,
221 (parameters) =>
222 parameters.get("work_mem")?.ParameterValue === "8192" &&
223 parameters.get("max_connections")?.ParameterValue === "200",
224 );
225 const overrides = { work_mem: "8192", max_connections: "200" };
226 expect(yield* userParameters(name)).toEqual(overrides);
227
228 const plan = yield* stack.plan(program());
229 expect(plan.resources.ObservedParameters1589?.action).toBe("update");
230 const observed = yield* stack.deploy(program());
231 expect(observed.parameters).toEqual({});
232 expect(yield* userParameters(name)).toEqual({});
233 const settled = yield* stack.plan(program());
234 expect(settled.resources.ObservedParameters1589?.action).toBe("noop");
235 const refreshed = yield* Drift.detect({ name: stack.name, stage: stack.stage }).pipe(
236 Effect.provide(stack.state),
237 );
238 expect(refreshed.resources.ObservedParameters1589).toMatchObject({
239 action: "unchanged",
240 attr: { parameters: {} },
241 });
242
243 const changed = yield* stack.deploy(program({ work_mem: "16384", max_connections: "250" }));
244 expect(changed.dbParameterGroupName).toBe(name);
245 expect(changed.dbParameterGroupArn).toBe(created.dbParameterGroupArn);
246 expect(changed.parameters).toEqual({ work_mem: "16384", max_connections: "250" });
247 // No test-side wait: reconcile must return observed, settled group values.
248 expect(yield* userParameters(name)).toEqual(changed.parameters);
249 const resetStatic = yield* stack.deploy(program({ work_mem: "16384" }));
250 expect(resetStatic.parameters).toEqual({ work_mem: "16384" });
251 expect(yield* userParameters(name)).toEqual(resetStatic.parameters);
252 const afterReset = (yield* groupParameters(name)).get("max_connections");
253 expect(afterReset?.Source).toBe(defaults.get("max_connections")?.Source);
254 expect(afterReset?.ParameterValue).toBe(defaults.get("max_connections")?.ParameterValue);
255
256 const cleared = yield* stack.deploy(program());
257 expect(cleared.parameters).toEqual({});
258 expect(yield* userParameters(name)).toEqual({});
259 expect((yield* groupParameters(name)).get("work_mem")?.ParameterValue).toBe(
260 defaults.get("work_mem")?.ParameterValue,
261 );
262 yield* stack.destroy();
263 yield* assertGroupGone(name);
264 }),
265 { tags: ["provider:aws", "provider:aws:rds", "live"], timeout: 120_000 },
266 );
267
268 test.provider(
269 "PR1589 refresh retains managed defaults after an out-of-band reset",
270 (stack) =>
271 Effect.gen(function* () {
272 yield* stack.destroy();
273 const program = (parameters?: Record<string, string>) =>
274 DBParameterGroup("DefaultParameters1589", { family: "postgres16", parameters });
275 const created = yield* stack.deploy(program());
276 const name = created.dbParameterGroupName;
277 const defaults = yield* groupParameters(name);
278 const parameter = defaults.get("log_autovacuum_min_duration");
279 expect(parameter?.Source).toBe("engine-default");
280 expect(parameter?.ApplyType).toBe("dynamic");
281 expect(parameter?.IsModifiable).toBe(true);
282 if (parameter?.ParameterValue === undefined) {
283 return yield* Effect.fail(
284 new Error("RDS did not report the log_autovacuum_min_duration default"),
285 );
286 }
287 const desired = { log_autovacuum_min_duration: parameter.ParameterValue };
288 const managed = yield* stack.deploy(program(desired));
289 expect(managed.parameters).toEqual(desired);
290 expect((yield* groupParameters(name)).get("log_autovacuum_min_duration")?.Source).toBe(
291 "engine-default",
292 );
293 const initial = yield* Drift.detect({ name: stack.name, stage: stack.stage }).pipe(
294 Effect.provide(stack.state),
295 );
296 expect(initial.resources.DefaultParameters1589).toMatchObject({
297 action: "unchanged",
298 attr: { parameters: desired },
299 });
300
301 const driftedValue = parameter.ParameterValue === "8192" ? "16384" : "8192";
302 yield* modifyParameters(name, [
303 {
304 ParameterName: "log_autovacuum_min_duration",
305 ParameterValue: driftedValue,
306 ApplyMethod: "immediate",
307 },
308 { ParameterName: "max_connections", ParameterValue: "200", ApplyMethod: "pending-reboot" },
309 ]);
310 yield* waitForParameters(
311 name,
312 (parameters) =>
313 parameters.get("log_autovacuum_min_duration")?.ParameterValue === driftedValue &&
314 parameters.get("max_connections")?.ParameterValue === "200",
315 );
316 const drift = yield* Drift.detect({ name: stack.name, stage: stack.stage }).pipe(
317 Effect.provide(stack.state),
318 );
319 expect(drift.resources.DefaultParameters1589?.attr.parameters).toEqual({
320 log_autovacuum_min_duration: driftedValue,
321 max_connections: "200",
322 });
323
324 yield* resetParameters(name, [
325 { ParameterName: "log_autovacuum_min_duration", ApplyMethod: "immediate" },
326 ]);
327 yield* waitForParameters(
328 name,
329 (parameters) =>
330 parameters.get("log_autovacuum_min_duration")?.Source === "engine-default" &&
331 parameters.get("log_autovacuum_min_duration")?.ParameterValue ===
332 desired.log_autovacuum_min_duration,
333 );
334 const reset = yield* Drift.detect({ name: stack.name, stage: stack.stage }).pipe(
335 Effect.provide(stack.state),
336 );
337 expect(reset.resources.DefaultParameters1589?.attr.parameters).toEqual({
338 ...desired,
339 max_connections: "200",
340 });
341 expect(yield* userParameters(name)).toEqual({ max_connections: "200" });
342 yield* stack.destroy();
343 yield* assertGroupGone(name);
344 }),
345 { tags: ["provider:aws", "provider:aws:rds", "live"], timeout: 120_000 },
346 );
347
348 test.provider(
349 "PR1590 adoption resets undeclared overrides to the same defaults as creation",
350 (stack) =>
351 Effect.gen(function* () {
352 yield* stack.destroy();
353 const name = "alchemy-test-pr1590-adopt-parameters";
354 yield* rds.createDBParameterGroup({
355 DBParameterGroupName: name,
356 DBParameterGroupFamily: "postgres16",
357 Description: "Desired-state adoption regression",
358 });
359 yield* modifyParameters(name, [
360 { ParameterName: "work_mem", ParameterValue: "8192", ApplyMethod: "immediate" },
361 ]);
362 yield* waitForParameters(
363 name,
364 (parameters) => parameters.get("work_mem")?.ParameterValue === "8192",
365 );
366 const program = DBParameterGroup("AdoptedParameters1590", {
367 dbParameterGroupName: name,
368 family: "postgres16",
369 description: "Desired-state adoption regression",
370 });
371 const adopted = yield* stack.deploy(program);
372 expect(adopted.parameters).toEqual({});
373 expect(yield* userParameters(name)).toEqual({});
374 expect((yield* stack.plan(program)).resources.AdoptedParameters1590?.action).toBe("noop");
375 yield* stack.destroy();
376 yield* assertGroupGone(name);
377 }),
378 { tags: ["provider:aws", "provider:aws:rds", "live"], timeout: 120_000 },
379 );
380
381 test.provider(
382 "PR1590 plans and repairs live modify/reset drift with unchanged props",
383 (stack) =>
384 Effect.gen(function* () {
385 yield* stack.destroy();
386 const program = (parameters?: Record<string, string>) =>
387 Effect.gen(function* () {
388 const group = yield* DBParameterGroup("DriftParameters1590", {
389 family: "postgres16",
390 parameters,
391 });
392 const dependent = yield* DBParameterGroup("StableReference1590", {
393 family: "postgres16",
394 tags: {
395 groupName: group.dbParameterGroupName,
396 groupArn: group.dbParameterGroupArn.as<string>(),
397 },
398 });
399 return { group, dependent };
400 });
401 const initial = yield* stack.deploy(program({}));
402 const name = initial.group.dbParameterGroupName;
403 const defaults = yield* groupParameters(name);
404 const parameter = defaults.get("log_autovacuum_min_duration");
405 expect(parameter?.Source).toBe("engine-default");
406 expect(parameter?.ApplyType).toBe("dynamic");
407 expect(parameter?.IsModifiable).toBe(true);
408 const defaultValue = parameter?.ParameterValue;
409 expect(defaultValue).toBeDefined();
410 const desired = { log_autovacuum_min_duration: defaultValue === "8192" ? "16384" : "8192" };
411 const created = yield* stack.deploy(program(desired));
412 yield* waitForParameters(
413 name,
414 (parameters) =>
415 parameters.get("log_autovacuum_min_duration")?.ParameterValue ===
416 desired.log_autovacuum_min_duration,
417 );
418 const clean = yield* stack.plan(program(desired));
419 expect(clean.resources.DriftParameters1590?.action).toBe("noop");
420 expect(clean.resources.StableReference1590?.action).toBe("noop");
421
422 const driftedValue = desired.log_autovacuum_min_duration === "8192" ? "16384" : "8192";
423 yield* modifyParameters(name, [
424 {
425 ParameterName: "log_autovacuum_min_duration",
426 ParameterValue: driftedValue,
427 ApplyMethod: "immediate",
428 },
429 { ParameterName: "max_connections", ParameterValue: "200", ApplyMethod: "pending-reboot" },
430 ]);
431 yield* waitForParameters(
432 name,
433 (parameters) =>
434 parameters.get("log_autovacuum_min_duration")?.ParameterValue === driftedValue &&
435 parameters.get("max_connections")?.ParameterValue === "200",
436 );
437 // No refresh before planning: persisted props and outputs still match.
438 const drift = yield* stack.plan(program(desired));
439 expect(drift.resources.DriftParameters1590?.action).toBe("update");
440 expect(drift.resources.StableReference1590?.action).toBe("noop");
441 expect(yield* userParameters(name)).toEqual({
442 log_autovacuum_min_duration: driftedValue,
443 max_connections: "200",
444 });
445
446 const repaired = yield* stack.deploy(program(desired));
447 expect(repaired.group.dbParameterGroupName).toBe(name);
448 expect(repaired.group.dbParameterGroupArn).toBe(created.group.dbParameterGroupArn);
449 expect(repaired.group.parameters).toEqual(desired);
450 expect(yield* userParameters(name)).toEqual(desired);
451 expect((yield* stack.plan(program(desired))).resources.DriftParameters1590?.action).toBe(
452 "noop",
453 );
454
455 yield* resetParameters(name, [
456 { ParameterName: "log_autovacuum_min_duration", ApplyMethod: "immediate" },
457 ]);
458 yield* waitForParameters(
459 name,
460 (parameters) =>
461 parameters.get("log_autovacuum_min_duration")?.Source === "engine-default" &&
462 parameters.get("log_autovacuum_min_duration")?.ParameterValue === defaultValue,
463 );
464 const resetDrift = yield* stack.plan(program(desired));
465 expect(resetDrift.resources.DriftParameters1590?.action).toBe("update");
466 expect(resetDrift.resources.StableReference1590?.action).toBe("noop");
467 expect(yield* userParameters(name)).toEqual({});
468 yield* stack.deploy(program(desired));
469 yield* waitForParameters(
470 name,
471 (parameters) =>
472 parameters.get("log_autovacuum_min_duration")?.ParameterValue ===
473 desired.log_autovacuum_min_duration,
474 );
475 expect(yield* userParameters(name)).toEqual(desired);
476
477 const omitted = yield* stack.deploy(program());
478 expect(omitted.group.parameters).toEqual({});
479 expect(yield* userParameters(name)).toEqual({});
480 yield* modifyParameters(name, [
481 { ParameterName: "max_connections", ParameterValue: "200", ApplyMethod: "pending-reboot" },
482 ]);
483 yield* waitForParameters(
484 name,
485 (parameters) => parameters.get("max_connections")?.ParameterValue === "200",
486 );
487 const omittedDrift = yield* stack.plan(program());
488 expect(omittedDrift.resources.DriftParameters1590?.action).toBe("update");
489 expect(omittedDrift.resources.StableReference1590?.action).toBe("noop");
490 const cleared = yield* stack.deploy(program());
491 expect(cleared.group.parameters).toEqual({});
492 expect(yield* userParameters(name)).toEqual({});
493 expect((yield* stack.plan(program())).resources.DriftParameters1590?.action).toBe("noop");
494 yield* stack.destroy();
495 yield* assertGroupGone(name);
496 yield* assertGroupGone(created.dependent.dbParameterGroupName);
497 }),
498 { tags: ["provider:aws", "provider:aws:rds", "live"], timeout: 240_000 },
499 );
500
501 test.provider(
502 "PR1590 treats a reset to an explicitly managed default as no drift",
503 (stack) =>
504 Effect.gen(function* () {
505 yield* stack.destroy();
506 const program = (parameters?: Record<string, string>) =>
507 DBParameterGroup("DefaultParameters1590", { family: "postgres16", parameters });
508 const created = yield* stack.deploy(program());
509 const name = created.dbParameterGroupName;
510 const parameter = (yield* groupParameters(name)).get("log_autovacuum_min_duration");
511 expect(parameter?.Source).toBe("engine-default");
512 expect(parameter?.ApplyType).toBe("dynamic");
513 expect(parameter?.IsModifiable).toBe(true);
514 if (parameter?.ParameterValue === undefined) {
515 return yield* Effect.fail(
516 new Error("RDS did not report the log_autovacuum_min_duration default"),
517 );
518 }
519 const desired = { log_autovacuum_min_duration: parameter.ParameterValue };
520 yield* stack.deploy(program(desired));
521 expect((yield* groupParameters(name)).get("log_autovacuum_min_duration")?.Source).toBe(
522 "engine-default",
523 );
524 expect((yield* stack.plan(program(desired))).resources.DefaultParameters1590?.action).toBe(
525 "noop",
526 );
527 const initial = yield* Drift.detect({ name: stack.name, stage: stack.stage }).pipe(
528 Effect.provide(stack.state),
529 );
530 expect(initial.resources.DefaultParameters1590).toMatchObject({
531 action: "unchanged",
532 attr: { parameters: desired },
533 });
534
535 const driftedValue = desired.log_autovacuum_min_duration === "8192" ? "16384" : "8192";
536 yield* modifyParameters(name, [
537 {
538 ParameterName: "log_autovacuum_min_duration",
539 ParameterValue: driftedValue,
540 ApplyMethod: "immediate",
541 },
542 ]);
543 yield* waitForParameters(
544 name,
545 (parameters) =>
546 parameters.get("log_autovacuum_min_duration")?.ParameterValue === driftedValue,
547 );
548 const drift = yield* stack.plan(program(desired));
549 expect(drift.resources.DefaultParameters1590?.action).toBe("update");
550 yield* stack.deploy(program(desired));
551 yield* waitForParameters(
552 name,
553 (parameters) =>
554 parameters.get("log_autovacuum_min_duration")?.ParameterValue ===
555 desired.log_autovacuum_min_duration,
556 );
557 // Writing the default value need not remove Source=user; reset does.
558 yield* resetParameters(name, [
559 { ParameterName: "log_autovacuum_min_duration", ApplyMethod: "immediate" },
560 ]);
561 yield* waitForParameters(
562 name,
563 (parameters) =>
564 parameters.get("log_autovacuum_min_duration")?.Source === "engine-default" &&
565 parameters.get("log_autovacuum_min_duration")?.ParameterValue ===
566 desired.log_autovacuum_min_duration,
567 );
568 expect(yield* userParameters(name)).toEqual({});
569 expect((yield* stack.plan(program(desired))).resources.DefaultParameters1590?.action).toBe(
570 "noop",
571 );
572 const reset = yield* Drift.detect({ name: stack.name, stage: stack.stage }).pipe(
573 Effect.provide(stack.state),
574 );
575 expect(reset.resources.DefaultParameters1590).toMatchObject({
576 action: "unchanged",
577 attr: { parameters: desired },
578 });
579 yield* stack.destroy();
580 yield* assertGroupGone(name);
581 }),
582 { tags: ["provider:aws", "provider:aws:rds", "live"], timeout: 120_000 },
583 );
584
585 test.provider(
586 "PR1590 clears stable references and recreates an out-of-band deleted group",
587 (stack) =>
588 Effect.gen(function* () {
589 yield* stack.destroy();
590 const program = Effect.gen(function* () {
591 const group = yield* DBParameterGroup("MissingParameters1590", {
592 family: "postgres16",
593 parameters: {},
594 });
595 const dependent = yield* DBParameterGroup("MissingReference1590", {
596 family: "postgres16",
597 tags: {
598 groupName: group.dbParameterGroupName,
599 groupArn: group.dbParameterGroupArn.as<string>(),
600 },
601 });
602 return { group, dependent };
603 });
604 const created = yield* stack.deploy(program);
605 const name = created.group.dbParameterGroupName;
606 const clean = yield* stack.plan(program);
607 expect(clean.resources.MissingParameters1590?.action).toBe("noop");
608 expect(clean.resources.MissingReference1590?.action).toBe("noop");
609
610 // Intentional drift, not cleanup: the engine must discover and recreate it.
611 yield* rds.deleteDBParameterGroup({ DBParameterGroupName: name }).pipe(
612 Effect.retry({
613 while: (error) => error._tag === "InvalidDBParameterGroupStateFault",
614 schedule: Schedule.spaced("3 seconds"),
615 times: 8,
616 }),
617 );
618 yield* assertGroupGone(name);
619 const missing = yield* stack.plan(program);
620 expect(missing.resources.MissingParameters1590?.action).toBe("update");
621 expect(missing.resources.MissingReference1590?.action).toBe("update");
622 yield* assertGroupGone(name);
623
624 const recreated = yield* stack.deploy(program);
625 expect(recreated.group.dbParameterGroupName).toBe(name);
626 expect(recreated.group.dbParameterGroupArn).toBe(created.group.dbParameterGroupArn);
627 expect(recreated.dependent.dbParameterGroupName).toBe(created.dependent.dbParameterGroupName);
628 const live = yield* rds.describeDBParameterGroups({ DBParameterGroupName: name });
629 expect(live.DBParameterGroups?.[0]?.DBParameterGroupArn).toBe(
630 created.group.dbParameterGroupArn,
631 );
632 expect((yield* stack.plan(program)).resources.MissingReference1590?.action).toBe("noop");
633 yield* stack.destroy();
634 yield* assertGroupGone(name);
635 yield* assertGroupGone(created.dependent.dbParameterGroupName);
636 }),
637 { tags: ["provider:aws", "provider:aws:rds", "live"], timeout: 120_000 },
638 );