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

main
ts 1,435 lines 51.4 KB
Raw
1 import * as AWS from "@alchemy.run/aws";
2 import { AWSEnvironment } from "@alchemy.run/aws/Environment";
3 import { normalizePolicyDocument, type PolicyStatement } from "@alchemy.run/aws/IAM/Policy";
4 import { Queue } from "@alchemy.run/aws/SQS";
5 import { describe, expect } from "@alchemy.run/test";
6 import * as Test from "@alchemy.run/test/Alchemy";
7 import * as SQS from "@distilled.cloud/aws/sqs";
8 import { adopt } from "alchemy/AdoptPolicy";
9 import * as Output from "alchemy/Output";
10 import * as Provider from "alchemy/Provider";
11 import { State } from "alchemy/State";
12 import * as Console from "effect/Console";
13 import * as Data from "effect/Data";
14 import * as Duration from "effect/Duration";
15 import * as Effect from "effect/Effect";
16 import * as HttpBody from "effect/http/HttpBody";
17 import * as HttpClient from "effect/http/HttpClient";
18 import * as Schedule from "effect/Schedule";
19 import { driftOf, repairDrift, waitForDrift } from "../drift.ts";
20 import { QueueSinkFunction, QueueSinkFunctionLive } from "./sink-handler";
21
22 const { test } = Test.make({ providers: AWS.providers() });
23
24 // A queue's identity. Its other outputs (observed attributes and tags) change
25 // with every update.
26 const queueIdentity = (queue: { queueName: string; queueUrl: string; queueArn: string }) => ({
27 queueName: queue.queueName,
28 queueUrl: queue.queueUrl,
29 queueArn: queue.queueArn,
30 });
31
32 const provider = test.provider;
33 const { test: adoptingTest } = Test.make({ providers: AWS.providers(), adopt: true });
34
35 for (const fifo of [false, true]) {
36 provider(
37 `self-bound ${fifo ? "FIFO" : "standard"} queue creates, updates, and clears policies`,
38 (stack) =>
39 Effect.gen(function* () {
40 yield* stack.destroy();
41
42 const { accountId, region } = yield* AWSEnvironment.current;
43 const queueName = fifo ? "alchemy-test-sqs-self-bound.fifo" : "alchemy-test-sqs-self-bound";
44 const principal = { AWS: `arn:aws:iam::${accountId}:root` };
45 const explicit: PolicyStatement = {
46 Sid: "Explicit",
47 Effect: "Allow",
48 Principal: principal,
49 Action: ["sqs:GetQueueAttributes"],
50 Resource: `arn:aws:sqs:${region}:${accountId}:${queueName}`,
51 };
52 const deployQueue = (
53 action: string | undefined,
54 withPolicy: boolean,
55 visibilityTimeout: "30 seconds" | "60 seconds",
56 ) =>
57 stack.deploy(
58 Effect.gen(function* () {
59 const props = {
60 queueName,
61 visibilityTimeout,
62 policy: withPolicy ? { Version: "2012-10-17", Statement: [explicit] } : undefined,
63 redriveAllowPolicy: withPolicy
64 ? { redrivePermission: "denyAll" as const }
65 : undefined,
66 tags: { phase: visibilityTimeout },
67 };
68 const queue = yield* Queue(
69 "SelfBoundQueue",
70 fifo
71 ? {
72 ...props,
73 fifo: true,
74 contentBasedDeduplication: true,
75 deduplicationScope: "messageGroup",
76 fifoThroughputLimit: "perMessageGroupId",
77 }
78 : props,
79 );
80 if (action !== undefined) {
81 yield* queue.bind`SelfPolicy`({
82 policyStatements: [
83 {
84 Sid: "SelfBound",
85 Effect: "Allow",
86 Principal: principal,
87 Action: [action],
88 Resource: queue.queueArn,
89 },
90 ],
91 });
92 }
93 return queue;
94 }),
95 );
96 const boundStatement = (queueArn: string, action: string): PolicyStatement => ({
97 Sid: "SelfBound",
98 Effect: "Allow",
99 Principal: principal,
100 Action: [action],
101 Resource: queueArn,
102 });
103
104 const created = yield* deployQueue("sqs:SendMessage", true, "30 seconds");
105 yield* waitForQueuePolicy(created.queueUrl, [
106 explicit,
107 boundStatement(created.queueArn, "sqs:SendMessage"),
108 ]);
109 yield* waitForQueueAttributeMatch(created.queueUrl, {
110 QueueArn: created.queueArn,
111 VisibilityTimeout: "30",
112 ...(fifo
113 ? {
114 FifoQueue: "true",
115 ContentBasedDeduplication: "true",
116 DeduplicationScope: "messageGroup",
117 FifoThroughputLimit: "perMessageGroupId",
118 }
119 : {}),
120 });
121 const tags = yield* SQS.listQueueTags({ QueueUrl: created.queueUrl });
122 expect(tags.Tags?.["alchemy::id"]).toBe("SelfBoundQueue");
123 expect(tags.Tags?.phase).toBe("30 seconds");
124
125 const updated = yield* deployQueue("sqs:ReceiveMessage", true, "30 seconds");
126 expect(queueIdentity(updated)).toEqual(queueIdentity(created));
127 yield* waitForQueuePolicy(updated.queueUrl, [
128 explicit,
129 boundStatement(created.queueArn, "sqs:ReceiveMessage"),
130 ]);
131 const unbound = yield* deployQueue(undefined, true, "60 seconds");
132 expect(queueIdentity(unbound)).toEqual(queueIdentity(created));
133 yield* waitForQueuePolicy(unbound.queueUrl, [explicit]);
134 yield* waitForQueueAttributeMatch(unbound.queueUrl, {
135 VisibilityTimeout: "60",
136 ...(fifo ? { FifoQueue: "true" } : {}),
137 });
138
139 const cleared = yield* deployQueue(undefined, false, "60 seconds");
140 expect(queueIdentity(cleared)).toEqual(queueIdentity(created));
141 yield* waitForQueueAttributePredicate(
142 cleared.queueUrl,
143 (attrs) => !attrs.Policy && !attrs.RedriveAllowPolicy,
144 );
145
146 yield* stack.destroy();
147 yield* assertQueueDeleted(created.queueUrl);
148 }),
149 { tags: ["provider:aws", "provider:aws:iam", "provider:aws:sqs", "live"], timeout: 120_000 },
150 );
151 }
152
153 // Outside a cycle the engine's ownership probe refuses the queue; a
154 // self-bound (cyclic) queue is precreated, and precreate refuses it itself.
155 for (const { fifo, cycle } of [
156 { fifo: false, cycle: false },
157 { fifo: true, cycle: false },
158 { fifo: false, cycle: true },
159 ]) {
160 const run = fifo ? adoptingTest.provider : provider;
161 run(
162 `preserves a foreign ${fifo ? "FIFO" : "standard"} queue when adoption is disabled on the ${cycle ? "self-bound " : ""}resource`,
163 (stack) =>
164 Effect.gen(function* () {
165 const { accountId } = yield* AWSEnvironment.current;
166 yield* stack.destroy();
167 const ownerProps = {
168 visibilityTimeout: Duration.seconds(45),
169 tags: { purpose: "original-owner" },
170 };
171 const ownerProgram = Queue("OwnerQueue", fifo ? { ...ownerProps, fifo: true } : ownerProps);
172 const owner = yield* stack.deploy(ownerProgram);
173 const originalTags = yield* SQS.listQueueTags({ QueueUrl: owner.queueUrl });
174 yield* SQS.sendMessage({
175 QueueUrl: owner.queueUrl,
176 MessageBody: "owned-message",
177 ...(fifo ? { MessageGroupId: "owner", MessageDeduplicationId: "owner" } : {}),
178 });
179
180 const conflict = yield* stack
181 .deploy(
182 Effect.gen(function* () {
183 yield* ownerProgram;
184 const dependency = yield* Queue("DependencyQueue");
185 const props = {
186 queueName: owner.queueName,
187 visibilityTimeout: Duration.seconds(90),
188 tags: { dependency: dependency.queueArn },
189 };
190 const intruder = yield* Queue(
191 "IntruderQueue",
192 fifo ? { ...props, fifo: true } : props,
193 ).pipe(adopt(false));
194 if (cycle) {
195 yield* intruder.bind`SelfPolicy`({
196 policyStatements: [
197 {
198 Sid: "SelfBound",
199 Effect: "Allow",
200 Principal: { AWS: `arn:aws:iam::${accountId}:root` },
201 Action: ["sqs:GetQueueAttributes"],
202 Resource: intruder.queueArn,
203 },
204 ],
205 });
206 }
207 return intruder;
208 }),
209 )
210 .pipe(Effect.flip);
211 expect(JSON.stringify(conflict)).toContain("OwnedBySomeoneElse");
212
213 const attributes = yield* SQS.getQueueAttributes({
214 QueueUrl: owner.queueUrl,
215 AttributeNames: ["All"],
216 });
217 expect(attributes.Attributes?.QueueArn).toBe(owner.queueArn);
218 expect(attributes.Attributes?.VisibilityTimeout).toBe("45");
219 expect(attributes.Attributes?.FifoQueue === "true").toBe(fifo);
220 expect((yield* SQS.listQueueTags({ QueueUrl: owner.queueUrl })).Tags).toEqual(
221 originalTags.Tags,
222 );
223
224 // Removing the failed create must not delete the foreign queue.
225 yield* stack.deploy(ownerProgram);
226 expect((yield* SQS.listQueueTags({ QueueUrl: owner.queueUrl })).Tags).toEqual(
227 originalTags.Tags,
228 );
229 const messages = yield* SQS.receiveMessage({
230 QueueUrl: owner.queueUrl,
231 WaitTimeSeconds: 10,
232 MaxNumberOfMessages: 1,
233 });
234 expect(messages.Messages?.map((message) => message.Body)).toEqual(["owned-message"]);
235 yield* stack.destroy();
236 yield* assertQueueDeleted(owner.queueUrl);
237 }),
238 { tags: ["provider:aws", "provider:aws:sqs", "live"], timeout: 120_000 },
239 );
240 }
241
242 describe.concurrent(
243 "queue mode changes",
244 { tags: ["provider:aws", "provider:aws:iam", "provider:aws:sqs", "live"] },
245 () => {
246 for (const initialFifo of [false, true]) {
247 for (const suffixed of [false, true]) {
248 provider(
249 `changing ${initialFifo ? "FIFO to standard" : "standard to FIFO"} with an explicit ${suffixed ? "suffixed" : "base"} name replaces the queue and updates references`,
250 (stack) =>
251 Effect.gen(function* () {
252 yield* stack.destroy();
253 const baseName = `alchemy-test-sqs-${stack.stage}-${initialFifo}-${suffixed}`;
254 const queueName = suffixed ? `${baseName}.fifo` : baseName;
255 const { accountId } = yield* AWSEnvironment.current;
256 const deployQueue = (fifo: boolean, visibilityTimeout: "30 seconds" | "45 seconds") =>
257 stack.deploy(
258 Effect.gen(function* () {
259 const settings = yield* fifo === initialFifo
260 ? Effect.succeed(undefined)
261 : Queue("SettingsSource");
262 const props = {
263 queueName,
264 visibilityTimeout: settings
265 ? settings.queueArn.pipe(Output.map(() => visibilityTimeout))
266 : visibilityTimeout,
267 };
268 const queue = yield* Queue("Queue", fifo ? { ...props, fifo: true } : props);
269 yield* queue.bind`SelfPolicy`({
270 policyStatements: [
271 {
272 Effect: "Allow",
273 Principal: { AWS: `arn:aws:iam::${accountId}:root` },
274 Action: ["sqs:SendMessage"],
275 Resource: queue.queueArn,
276 },
277 ],
278 });
279 const reference = yield* Queue("Reference", {
280 tags: { target: queue.queueArn },
281 });
282 return { queue, reference };
283 }),
284 );
285 const original = yield* deployQueue(initialFifo, "30 seconds");
286 expect(original.queue.queueName).toBe(initialFifo ? `${baseName}.fifo` : baseName);
287 const replacement = yield* deployQueue(!initialFifo, "30 seconds");
288 expect(replacement.queue.queueName).toBe(initialFifo ? baseName : `${baseName}.fifo`);
289 expect(replacement.queue.queueArn).not.toBe(original.queue.queueArn);
290 expect(queueIdentity(replacement.reference)).toEqual(
291 queueIdentity(original.reference),
292 );
293 yield* waitForQueueTags(
294 replacement.reference.queueUrl,
295 (tags) => tags.target === replacement.queue.queueArn,
296 );
297 yield* waitForQueueAttributeMatch(replacement.queue.queueUrl, {
298 QueueArn: replacement.queue.queueArn,
299 VisibilityTimeout: "30",
300 });
301 const attributes = yield* SQS.getQueueAttributes({
302 QueueUrl: replacement.queue.queueUrl,
303 AttributeNames: ["All"],
304 });
305 expect(attributes.Attributes?.FifoQueue === "true").toBe(!initialFifo);
306 yield* waitForQueuePolicy(replacement.queue.queueUrl, [
307 {
308 Effect: "Allow",
309 Principal: { AWS: `arn:aws:iam::${accountId}:root` },
310 Action: ["sqs:SendMessage"],
311 Resource: replacement.queue.queueArn,
312 },
313 ]);
314 yield* assertQueueDeleted(original.queue.queueUrl);
315 const updated = yield* deployQueue(!initialFifo, "45 seconds");
316 expect(queueIdentity(updated.queue)).toEqual(queueIdentity(replacement.queue));
317 expect(queueIdentity(updated.reference)).toEqual(
318 queueIdentity(replacement.reference),
319 );
320 yield* waitForQueueAttributeMatch(updated.queue.queueUrl, {
321 VisibilityTimeout: "45",
322 });
323 yield* SQS.sendMessage({
324 QueueUrl: updated.queue.queueUrl,
325 MessageBody: "replacement-message",
326 ...(!initialFifo
327 ? { MessageGroupId: "replacement", MessageDeduplicationId: "replacement" }
328 : {}),
329 });
330 const messages = yield* SQS.receiveMessage({
331 QueueUrl: updated.queue.queueUrl,
332 WaitTimeSeconds: 10,
333 MaxNumberOfMessages: 1,
334 });
335 expect(messages.Messages?.map((message) => message.Body)).toEqual([
336 "replacement-message",
337 ]);
338 yield* stack.destroy();
339 yield* assertQueueDeleted(updated.queue.queueUrl);
340 yield* assertQueueDeleted(updated.reference.queueUrl);
341 }),
342 { timeout: 120_000 },
343 );
344 }
345 }
346 },
347 );
348
349 provider(
350 "create and delete queue with default props",
351 (stack) =>
352 Effect.gen(function* () {
353 yield* stack.destroy();
354
355 const queue = yield* stack.deploy(
356 Effect.gen(function* () {
357 return yield* Queue("DefaultQueue");
358 }),
359 );
360
361 expect(queue.queueName).toBeDefined();
362 expect(queue.queueUrl).toBeDefined();
363 expect(queue.queueArn).toBeDefined();
364
365 const queueAttributes = yield* SQS.getQueueAttributes({
366 QueueUrl: queue.queueUrl,
367 AttributeNames: ["All"],
368 });
369 expect(queueAttributes.Attributes?.QueueArn).toBe(queue.queueArn);
370 expect(queueAttributes.Attributes?.Policy).toBeFalsy();
371 expect(queueAttributes.Attributes?.FifoQueue).not.toBe("true");
372 expect(queueAttributes.Attributes?.VisibilityTimeout).toBe("30");
373
374 yield* SQS.sendMessage({ QueueUrl: queue.queueUrl, MessageBody: "default-queue-message" });
375 expect(yield* waitForQueueMessage(queue.queueUrl)).toBe("default-queue-message");
376
377 yield* stack.destroy();
378
379 yield* assertQueueDeleted(queue.queueUrl);
380 }),
381 { tags: ["provider:aws", "provider:aws:sqs", "live"] },
382 );
383
384 provider(
385 "create, update, delete standard queue",
386 (stack) =>
387 Effect.gen(function* () {
388 yield* stack.destroy();
389
390 const queue = yield* stack.deploy(
391 Effect.gen(function* () {
392 return yield* Queue("TestQueue", {
393 visibilityTimeout: "30 seconds",
394 delay: "0 seconds",
395 // exercise the non-string Duration.Input forms end-to-end
396 messageRetentionPeriod: Duration.days(4),
397 receiveMessageWaitTime: 10_000, // bare number = millis
398 });
399 }),
400 );
401
402 // Verify the queue was created
403 const queueAttributes = yield* SQS.getQueueAttributes({
404 QueueUrl: queue.queueUrl,
405 AttributeNames: ["All"],
406 });
407 expect(queueAttributes.Attributes?.VisibilityTimeout).toEqual("30");
408 expect(queueAttributes.Attributes?.DelaySeconds).toEqual("0");
409 expect(queueAttributes.Attributes?.MessageRetentionPeriod).toEqual("345600");
410 expect(queueAttributes.Attributes?.ReceiveMessageWaitTimeSeconds).toEqual("10");
411
412 // Update the queue
413 const updatedQueue = yield* stack.deploy(
414 Effect.gen(function* () {
415 return yield* Queue("TestQueue", {
416 visibilityTimeout: "60 seconds",
417 delay: "5 seconds",
418 messageRetentionPeriod: "5 days",
419 receiveMessageWaitTime: "20 seconds",
420 });
421 }),
422 );
423
424 // Verify the queue was updated (reads can lag briefly after SetQueueAttributes)
425 yield* waitForQueueAttributeMatch(updatedQueue.queueUrl, {
426 VisibilityTimeout: "60",
427 DelaySeconds: "5",
428 MessageRetentionPeriod: "432000",
429 ReceiveMessageWaitTimeSeconds: "20",
430 });
431
432 yield* stack.destroy();
433
434 yield* assertQueueDeleted(queue.queueUrl);
435 }),
436 { tags: ["provider:aws", "provider:aws:sqs", "live"] },
437 );
438
439 provider(
440 "create, update, delete fifo queue",
441 (stack) =>
442 Effect.gen(function* () {
443 yield* stack.destroy();
444
445 const queue = yield* stack.deploy(
446 Effect.gen(function* () {
447 return yield* Queue("TestFifoQueue", {
448 fifo: true,
449 contentBasedDeduplication: false,
450 visibilityTimeout: "30 seconds",
451 });
452 }),
453 );
454
455 // Verify the FIFO queue was created
456 expect(queue.queueUrl).toContain(".fifo");
457 expect(queue.queueName).toContain(".fifo");
458
459 const queueAttributes = yield* SQS.getQueueAttributes({
460 QueueUrl: queue.queueUrl,
461 AttributeNames: ["All"],
462 });
463 expect(queueAttributes.Attributes?.FifoQueue).toEqual("true");
464 expect(queueAttributes.Attributes?.ContentBasedDeduplication).toEqual("false");
465
466 // Update the FIFO queue to enable content-based deduplication
467 const updatedQueue = yield* stack.deploy(
468 Effect.gen(function* () {
469 return yield* Queue("TestFifoQueue", {
470 fifo: true,
471 contentBasedDeduplication: true,
472 visibilityTimeout: "60 seconds",
473 });
474 }),
475 );
476
477 // Verify the queue was updated (reads can lag briefly after SetQueueAttributes)
478 yield* waitForQueueAttributeMatch(updatedQueue.queueUrl, {
479 ContentBasedDeduplication: "true",
480 VisibilityTimeout: "60",
481 });
482
483 yield* stack.destroy();
484
485 yield* assertQueueDeleted(queue.queueUrl);
486 }),
487 { tags: ["provider:aws", "provider:aws:sqs", "live"] },
488 );
489
490 provider(
491 "create queue with custom name",
492 (stack) =>
493 Effect.gen(function* () {
494 yield* stack.destroy();
495
496 const queue = yield* stack.deploy(
497 Effect.gen(function* () {
498 return yield* Queue("CustomNameQueue", { queueName: "my-custom-test-queue" });
499 }),
500 );
501
502 expect(queue.queueName).toEqual("my-custom-test-queue");
503 expect(queue.queueUrl).toContain("my-custom-test-queue");
504
505 // Verify the queue exists
506 const queueAttributes = yield* SQS.getQueueAttributes({
507 QueueUrl: queue.queueUrl,
508 AttributeNames: ["All"],
509 });
510 expect(queueAttributes.Attributes).toBeDefined();
511
512 yield* stack.destroy();
513
514 yield* assertQueueDeleted(queue.queueUrl);
515 }),
516 { tags: ["provider:aws", "provider:aws:sqs", "live"] },
517 );
518
519 describe.concurrent(
520 "queue runtime and recovery",
521 { tags: ["provider:aws", "provider:aws:sqs", "live"] },
522 () => {
523 provider(
524 "QueueSink writes arbitrary messages through a deployed Lambda",
525 (stack) =>
526 Effect.gen(function* () {
527 yield* stack.destroy();
528
529 const apiFunction = yield* stack.deploy(
530 QueueSinkFunction.pipe(Effect.provide(QueueSinkFunctionLive)),
531 );
532 const baseUrl = apiFunction.functionUrl!.replace(/\/+$/, "");
533
534 const { queueUrl } = yield* waitForFunctionReady(`${baseUrl}/ready`);
535
536 // 25 messages > the SendMessageBatch limit of 10, so the batched sink
537 // must split the chunk into 3 sequential API calls (10 + 10 + 5).
538 const messages = Array.from({ length: 25 }, (_, i) => `sink-${i}-${crypto.randomUUID()}`);
539 const response = yield* HttpClient.post(`${baseUrl}/sink`, {
540 body: yield* HttpBody.json({ messages }),
541 }).pipe(
542 // QueueSink can legitimately spend several seconds retrying a partial
543 // batch failure, but a stalled Function URL request must not consume
544 // the whole test timeout.
545 Effect.timeout("15 seconds"),
546 Effect.mapError(() => "not ready" as const),
547 Effect.flatMap((result) =>
548 result.status === 200 ? Effect.succeed(result) : Effect.fail("not ready"),
549 ),
550 Effect.tapError(Console.log),
551 Effect.retry({
552 while: (error) => error === "not ready",
553 schedule: Schedule.fixed("3 seconds"),
554 times: 4,
555 }),
556 Effect.flatMap((result) => result.json),
557 );
558
559 expect((response as any).ok).toBe(true);
560 expect((response as any).count).toBe(messages.length);
561
562 const received = yield* waitForQueueMessages(queueUrl, messages.length);
563
564 expect(received.sort()).toEqual([...messages].sort());
565
566 yield* stack.destroy();
567
568 yield* assertQueueDeleted(queueUrl);
569 }),
570 { tags: ["provider:aws:lambda"], timeout: 240_000 },
571 );
572
573 provider(
574 "self-bound queue recovers a missing physical queue with persisted output",
575 (stack) =>
576 Effect.gen(function* () {
577 yield* stack.destroy();
578
579 const { accountId } = yield* AWSEnvironment.current;
580 const principal = { AWS: `arn:aws:iam::${accountId}:root` };
581 const deployQueue = (
582 visibilityTimeout: "30 seconds" | "60 seconds",
583 withBinding = true,
584 ) =>
585 stack.deploy(
586 Effect.gen(function* () {
587 const queue = yield* Queue("RecoveryQueue", {
588 visibilityTimeout,
589 tags: { purpose: "recovery" },
590 });
591 if (withBinding) {
592 yield* queue.bind`SelfPolicy`({
593 policyStatements: [
594 {
595 Effect: "Allow",
596 Principal: principal,
597 Action: ["sqs:SendMessage"],
598 Resource: queue.queueArn,
599 },
600 ],
601 });
602 }
603 return queue;
604 }),
605 );
606 const initial = yield* deployQueue("30 seconds");
607 yield* waitForQueuePolicy(initial.queueUrl, [
608 {
609 Effect: "Allow",
610 Principal: principal,
611 Action: ["sqs:SendMessage"],
612 Resource: initial.queueArn,
613 },
614 ]);
615
616 yield* SQS.deleteQueue({ QueueUrl: initial.queueUrl });
617 yield* assertQueueDeleted(initial.queueUrl);
618 const recovered = yield* deployQueue("60 seconds");
619 expect(queueIdentity(recovered)).toEqual(queueIdentity(initial));
620 yield* waitForQueueAttributeMatch(recovered.queueUrl, {
621 QueueArn: initial.queueArn,
622 VisibilityTimeout: "60",
623 });
624 yield* waitForQueuePolicy(recovered.queueUrl, [
625 {
626 Effect: "Allow",
627 Principal: principal,
628 Action: ["sqs:SendMessage"],
629 Resource: recovered.queueArn,
630 },
631 ]);
632 const tags = yield* SQS.listQueueTags({ QueueUrl: recovered.queueUrl });
633 expect(tags.Tags?.purpose).toBe("recovery");
634 expect(tags.Tags?.["alchemy::id"]).toBe("RecoveryQueue");
635
636 const unbound = yield* deployQueue("60 seconds", false);
637 expect(queueIdentity(unbound)).toEqual(queueIdentity(recovered));
638 yield* waitForQueueAttributePredicate(unbound.queueUrl, (attrs) => !attrs.Policy);
639
640 yield* stack.destroy();
641 yield* assertQueueDeleted(recovered.queueUrl);
642 }),
643 { tags: ["provider:aws:iam"], timeout: 120_000 },
644 );
645 },
646 );
647
648 // State-loss fixtures need cleanup even if adoption fails before state is restored.
649 const ADOPT_QUEUE_NAME = "alchemy-test-sqs-adopt";
650 const TAKEOVER_QUEUE_NAME = "alchemy-test-sqs-takeover";
651
652 provider(
653 "owned queue (matching alchemy tags) is silently adopted without --adopt",
654 (stack) =>
655 Effect.gen(function* () {
656 yield* stack.destroy();
657
658 const queueName = ADOPT_QUEUE_NAME;
659
660 const { accountId, region } = yield* AWSEnvironment.current;
661 const principal = { AWS: `arn:aws:iam::${accountId}:root` };
662 const initial = yield* stack.deploy(
663 Effect.gen(function* () {
664 return yield* Queue("AdoptableQueue", {
665 queueName,
666 visibilityTimeout: "30 seconds",
667 redriveAllowPolicy: { redrivePermission: "denyAll" },
668 tags: { stale: "remove" },
669 policy: {
670 Statement: [
671 {
672 Sid: "Stale",
673 Effect: "Allow",
674 Principal: principal,
675 Action: ["sqs:GetQueueAttributes"],
676 Resource: `arn:aws:sqs:${region}:${accountId}:${queueName}`,
677 },
678 ],
679 },
680 });
681 }),
682 );
683 expect(initial.queueName).toEqual(queueName);
684 yield* waitForQueueAttributePredicate(
685 initial.queueUrl,
686 (attrs) => !!attrs.Policy && !!attrs.RedriveAllowPolicy,
687 );
688
689 // Wipe state — queue stays in SQS.
690 yield* Effect.gen(function* () {
691 const state = yield* yield* State;
692 yield* state.delete({ stack: stack.name, stage: stack.stage, fqn: "AdoptableQueue" });
693 }).pipe(Effect.provide(stack.state));
694
695 const adopted = yield* stack.deploy(
696 Effect.gen(function* () {
697 const dependency = yield* Queue("AdoptionDependency");
698 const queue = yield* Queue("AdoptableQueue", {
699 queueName,
700 visibilityTimeout: "60 seconds",
701 tags: { adopted: dependency.queueArn.pipe(Output.map(() => "true")) },
702 });
703 yield* queue.bind`SelfPolicy`({
704 policyStatements: [
705 {
706 Effect: "Allow",
707 Principal: principal,
708 Action: ["sqs:SendMessage"],
709 Resource: queue.queueArn,
710 },
711 ],
712 });
713 return queue;
714 }),
715 );
716
717 expect(adopted.queueArn).toEqual(initial.queueArn);
718 expect(adopted.queueUrl).toEqual(initial.queueUrl);
719 yield* waitForQueuePolicy(adopted.queueUrl, [
720 {
721 Effect: "Allow",
722 Principal: principal,
723 Action: ["sqs:SendMessage"],
724 Resource: adopted.queueArn,
725 },
726 ]);
727 yield* waitForQueueAttributePredicate(
728 adopted.queueUrl,
729 (attrs) => attrs.VisibilityTimeout === "60" && !attrs.RedriveAllowPolicy,
730 );
731 yield* waitForQueueTags(
732 adopted.queueUrl,
733 (tags) =>
734 tags.adopted === "true" &&
735 tags.stale === undefined &&
736 tags["alchemy::id"] === "AdoptableQueue",
737 );
738
739 yield* stack.destroy();
740 yield* assertQueueDeleted(initial.queueUrl);
741 }).pipe(Effect.ensuring(deleteQueueIfExists(ADOPT_QUEUE_NAME).pipe(Effect.orDie))),
742 { tags: ["provider:aws", "provider:aws:iam", "provider:aws:sqs", "live"] },
743 );
744
745 describe.concurrent("queue adoption", () => {
746 for (const scope of ["resolved", "resource", "stack", "default"] as const) {
747 const queueName = `${TAKEOVER_QUEUE_NAME}-${scope}`;
748 const run = scope === "default" ? adoptingTest.provider : provider;
749 run(
750 `foreign-tagged queue converges settings and policies during ${scope} adoption`,
751 (stack) =>
752 Effect.gen(function* () {
753 yield* stack.destroy();
754 const { accountId } = yield* AWSEnvironment.current;
755 const principal = { AWS: `arn:aws:iam::${accountId}:root` };
756 const original = yield* stack.deploy(
757 Queue("Original", { queueName, tags: { stale: "remove" } }),
758 );
759 yield* SQS.sendMessage({
760 QueueUrl: original.queueUrl,
761 MessageBody: "adopted-message",
762 }).pipe(
763 Effect.retry({
764 while: (error) => error._tag === "QueueDoesNotExist",
765 schedule: Schedule.spaced("1 second"),
766 times: 10,
767 }),
768 );
769 yield* Effect.gen(function* () {
770 const state = yield* yield* State;
771 yield* state.delete({ stack: stack.name, stage: stack.stage, fqn: "Original" });
772 }).pipe(Effect.provide(stack.state));
773 const deployment = stack.deploy(
774 Effect.gen(function* () {
775 const dependency = yield* Queue("AdoptionDependency");
776 const registration = Queue("Different", {
777 queueName,
778 visibilityTimeout:
779 scope === "resolved"
780 ? Duration.seconds(60)
781 : dependency.queueArn.pipe(Output.map(() => Duration.seconds(60))),
782 tags: {
783 adopted:
784 scope === "resolved"
785 ? "true"
786 : dependency.queueArn.pipe(Output.map(() => "true")),
787 },
788 });
789 const queue = yield* scope === "resource"
790 ? registration.pipe(adopt(true))
791 : registration;
792 yield* queue.bind`SelfPolicy`({
793 policyStatements: [
794 {
795 Effect: "Allow",
796 Principal: principal,
797 Action: ["sqs:SendMessage"],
798 Resource: queue.queueArn,
799 },
800 ],
801 });
802 return { queue, dependency };
803 }),
804 );
805 const { queue: takenOver, dependency } = yield* scope === "stack" || scope === "resolved"
806 ? deployment.pipe(adopt(true))
807 : deployment;
808 expect(takenOver.queueName).toBe(queueName);
809 expect(takenOver.queueUrl).toBe(original.queueUrl);
810 yield* waitForQueuePolicy(takenOver.queueUrl, [
811 {
812 Effect: "Allow",
813 Principal: principal,
814 Action: ["sqs:SendMessage"],
815 Resource: takenOver.queueArn,
816 },
817 ]);
818 yield* waitForQueueTags(
819 takenOver.queueUrl,
820 (tags) =>
821 tags["alchemy::id"] === "Different" &&
822 tags.adopted === "true" &&
823 tags.stale === undefined,
824 );
825 yield* waitForQueueAttributeMatch(takenOver.queueUrl, { VisibilityTimeout: "60" });
826 const messages = yield* SQS.receiveMessage({
827 QueueUrl: takenOver.queueUrl,
828 WaitTimeSeconds: 10,
829 MaxNumberOfMessages: 1,
830 });
831 expect(messages.Messages?.map((message) => message.Body)).toEqual(["adopted-message"]);
832 yield* stack.destroy();
833 yield* assertQueueDeleted(takenOver.queueUrl);
834 yield* assertQueueDeleted(dependency.queueUrl);
835 }).pipe(Effect.ensuring(deleteQueueIfExists(queueName).pipe(Effect.orDie))),
836 { tags: ["provider:aws", "provider:aws:sqs", "live"], timeout: 120_000 },
837 );
838 }
839 });
840
841 provider(
842 "list enumerates the deployed queue",
843 (stack) =>
844 Effect.gen(function* () {
845 yield* stack.destroy();
846
847 const deployed = yield* stack.deploy(
848 Effect.gen(function* () {
849 return yield* Queue("ListQueue");
850 }),
851 );
852
853 const provider = yield* Provider.findProvider(Queue);
854
855 // SQS is eventually consistent: a freshly-created queue may not appear in
856 // listQueues immediately. Retry the list assertion on a bounded schedule.
857 yield* Effect.gen(function* () {
858 const all = yield* provider.list();
859 if (!all.some((q) => q.queueArn === deployed.queueArn)) {
860 return yield* Effect.fail(new QueueNotListed());
861 }
862 }).pipe(
863 Effect.retry({
864 while: (e) => e._tag === "QueueNotListed",
865 schedule: Schedule.spaced("3 seconds"),
866 times: 10,
867 }),
868 );
869
870 yield* stack.destroy();
871
872 yield* assertQueueDeleted(deployed.queueUrl);
873 }),
874 { tags: ["provider:aws", "provider:aws:sqs", "live"], timeout: 120_000 },
875 );
876
877 provider(
878 "DLQ redrive policy round-trips and can be removed",
879 (stack) =>
880 Effect.gen(function* () {
881 yield* stack.destroy();
882
883 // Create the DLQ and source together, keeping both deployed across
884 // steps to avoid the engine replace+remove-dependency deadlock.
885 const deployBoth = (withRedrive: boolean) =>
886 stack.deploy(
887 Effect.gen(function* () {
888 const dlq = yield* Queue("RedriveDLQ");
889 const source = yield* Queue(
890 "RedriveSource",
891 withRedrive
892 ? { redrivePolicy: { deadLetterTargetArn: dlq.queueArn, maxReceiveCount: 3 } }
893 : {},
894 );
895 return { dlq, source };
896 }),
897 );
898
899 const { source } = yield* deployBoth(true);
900
901 yield* waitForQueueAttributePredicate(source.queueUrl, (attrs) => {
902 if (!attrs.RedrivePolicy) return false;
903 const parsed = JSON.parse(attrs.RedrivePolicy);
904 return parsed.maxReceiveCount === 3;
905 });
906
907 // Remove the redrive policy on update; it must be cleared.
908 const { source: updated } = yield* deployBoth(false);
909 yield* waitForQueueAttributePredicate(updated.queueUrl, (attrs) => !attrs.RedrivePolicy);
910
911 yield* stack.destroy();
912 yield* assertQueueDeleted(source.queueUrl);
913 }),
914 { tags: ["provider:aws", "provider:aws:sqs", "live"], timeout: 120_000 },
915 );
916
917 provider(
918 "redriveAllowPolicy is set on the dead-letter queue",
919 (stack) =>
920 Effect.gen(function* () {
921 yield* stack.destroy();
922
923 const { dlq } = yield* stack.deploy(
924 Effect.gen(function* () {
925 const source = yield* Queue("AllowSource");
926 const dlq = yield* Queue("AllowDLQ", {
927 redriveAllowPolicy: {
928 redrivePermission: "byQueue",
929 sourceQueueArns: [source.queueArn],
930 },
931 });
932 return { source, dlq };
933 }),
934 );
935
936 yield* waitForQueueAttributePredicate(dlq.queueUrl, (attrs) => {
937 if (!attrs.RedriveAllowPolicy) return false;
938 const parsed = JSON.parse(attrs.RedriveAllowPolicy);
939 return parsed.redrivePermission === "byQueue";
940 });
941
942 yield* stack.destroy();
943 yield* assertQueueDeleted(dlq.queueUrl);
944 }),
945 { tags: ["provider:aws", "provider:aws:sqs", "live"], timeout: 120_000 },
946 );
947
948 provider(
949 "SSE-SQS encryption enables sqs-managed key",
950 (stack) =>
951 Effect.gen(function* () {
952 yield* stack.destroy();
953
954 const queue = yield* stack.deploy(
955 Effect.gen(function* () {
956 return yield* Queue("SseSqsQueue", { sqsManagedSseEnabled: true });
957 }),
958 );
959
960 yield* waitForQueueAttributeMatch(queue.queueUrl, { SqsManagedSseEnabled: "true" });
961
962 yield* stack.destroy();
963 yield* assertQueueDeleted(queue.queueUrl);
964 }),
965 { tags: ["provider:aws", "provider:aws:sqs", "live"] },
966 );
967
968 provider(
969 "SSE-KMS encryption with AWS-managed key",
970 (stack) =>
971 Effect.gen(function* () {
972 yield* stack.destroy();
973
974 const queue = yield* stack.deploy(
975 Effect.gen(function* () {
976 return yield* Queue("KmsQueue", {
977 kmsMasterKeyId: "alias/aws/sqs",
978 kmsDataKeyReusePeriod: "300 seconds",
979 });
980 }),
981 );
982
983 yield* waitForQueueAttributeMatch(queue.queueUrl, {
984 KmsMasterKeyId: "alias/aws/sqs",
985 KmsDataKeyReusePeriodSeconds: "300",
986 });
987
988 yield* stack.destroy();
989 yield* assertQueueDeleted(queue.queueUrl);
990 }),
991 { tags: ["provider:aws", "provider:aws:sqs", "live"] },
992 );
993
994 provider(
995 "SSE-KMS accepts an Output-valued false SSE-SQS setting during precreate",
996 (stack) =>
997 Effect.gen(function* () {
998 yield* stack.destroy();
999 const { source, queue } = yield* stack.deploy(
1000 Effect.gen(function* () {
1001 const source = yield* Queue("EncryptionSource");
1002 const queue = yield* Queue("OutputKmsQueue", {
1003 kmsMasterKeyId: "alias/aws/sqs",
1004 sqsManagedSseEnabled: source.queueArn.pipe(Output.map(() => false)),
1005 });
1006 return { source, queue };
1007 }),
1008 );
1009 yield* waitForQueueAttributeMatch(queue.queueUrl, { KmsMasterKeyId: "alias/aws/sqs" });
1010 yield* stack.destroy();
1011 yield* assertQueueDeleted(source.queueUrl);
1012 yield* assertQueueDeleted(queue.queueUrl);
1013 }),
1014 { tags: ["provider:aws", "provider:aws:sqs", "live"], timeout: 120_000 },
1015 );
1016
1017 provider(
1018 "kmsMasterKeyId and sqsManagedSseEnabled together fail fast",
1019 (stack) =>
1020 Effect.gen(function* () {
1021 yield* stack.destroy();
1022
1023 const result = yield* stack
1024 .deploy(
1025 Effect.gen(function* () {
1026 return yield* Queue("ConflictQueue", {
1027 kmsMasterKeyId: "alias/aws/sqs",
1028 sqsManagedSseEnabled: true,
1029 });
1030 }),
1031 )
1032 .pipe(Effect.flip);
1033
1034 // The typed validation error surfaces (possibly wrapped by the engine).
1035 expect(JSON.stringify(result)).toContain("SqsEncryptionConflict");
1036
1037 yield* stack.destroy();
1038 }),
1039 { tags: ["provider:aws", "provider:aws:sqs", "live"] },
1040 );
1041
1042 for (const property of ["fifo", "queueName"] as const) {
1043 // Distinct names: the variants run concurrently.
1044 const nameFor = (selfBound: boolean) =>
1045 `alchemy-test-sqs-${selfBound ? "unresolved" : "resolved"}-${property.toLowerCase()}`;
1046 const unresolvedIdentity = (selfBound: boolean) =>
1047 Effect.gen(function* () {
1048 const queueName = nameFor(selfBound);
1049 const source = yield* Queue("IdentitySource");
1050 const queue = yield* Queue(
1051 "UnresolvedIdentity",
1052 property === "fifo"
1053 ? { queueName, fifo: source.queueArn.pipe(Output.map(() => false as const)) }
1054 : { queueName: source.queueArn.pipe(Output.map(() => queueName)) },
1055 );
1056 if (selfBound) {
1057 const { accountId } = yield* AWSEnvironment.current;
1058 yield* queue.bind`SelfPolicy`({
1059 policyStatements: [
1060 {
1061 Sid: "SelfBound",
1062 Effect: "Allow",
1063 Principal: { AWS: `arn:aws:iam::${accountId}:root` },
1064 Action: ["sqs:GetQueueAttributes"],
1065 Resource: queue.queueArn,
1066 },
1067 ],
1068 });
1069 }
1070 return queue;
1071 });
1072
1073 // Outside a cycle there is no precreate: reconcile runs after the upstream
1074 // resolves, so the identity is known before the queue is created.
1075 provider(
1076 `creates a queue whose ${property} resolves from an upstream output`,
1077 (stack) =>
1078 Effect.gen(function* () {
1079 yield* stack.destroy();
1080 const queue = yield* stack.deploy(unresolvedIdentity(false));
1081 expect(queue.queueName).toBe(nameFor(false));
1082 yield* stack.destroy();
1083 yield* assertQueueDeleted(queue.queueUrl);
1084 }),
1085 { tags: ["provider:aws", "provider:aws:sqs", "live"], timeout: 120_000 },
1086 );
1087
1088 // A self-bound queue is precreated to break its cycle, and the engine
1089 // resolves props from outside the cycle first: the upstream output is known
1090 // at precreate, so the queue gets its real identity and its policy binding.
1091 provider(
1092 `precreates a self-bound queue with a ${property} resolved from outside the cycle`,
1093 (stack) =>
1094 Effect.gen(function* () {
1095 yield* stack.destroy();
1096 const queue = yield* stack.deploy(unresolvedIdentity(true));
1097 // A standard queue: the name carries no `.fifo` suffix.
1098 expect(queue.queueName).toBe(nameFor(true));
1099 const { Attributes } = yield* SQS.getQueueAttributes({
1100 QueueUrl: queue.queueUrl,
1101 AttributeNames: ["Policy"],
1102 });
1103 expect(Attributes?.Policy).toContain("SelfBound");
1104 yield* stack.destroy();
1105 yield* assertQueueDeleted(queue.queueUrl);
1106 }),
1107 { tags: ["provider:aws", "provider:aws:sqs", "live"], timeout: 120_000 },
1108 );
1109 }
1110
1111 provider(
1112 "missing dead-letter queues produce a typed validation error",
1113 (stack) =>
1114 Effect.gen(function* () {
1115 yield* stack.destroy();
1116 const queue = yield* stack.deploy(Queue("MissingDeadLetterQueueSource"));
1117 const { accountId, region } = yield* AWSEnvironment.current;
1118 const result = yield* SQS.setQueueAttributes({
1119 QueueUrl: queue.queueUrl,
1120 Attributes: {
1121 RedrivePolicy: JSON.stringify({
1122 deadLetterTargetArn: `arn:aws:sqs:${region}:${accountId}:alchemy-test-sqs-missing-dead-letter`,
1123 maxReceiveCount: 3,
1124 }),
1125 },
1126 }).pipe(Effect.flip);
1127 expect(result._tag).toBe("InvalidParameterValueException");
1128 expect(result.message).toContain("Dead letter target does not exist");
1129 yield* stack.destroy();
1130 yield* assertQueueDeleted(queue.queueUrl);
1131 }),
1132 { tags: ["provider:aws", "provider:aws:sqs", "live"] },
1133 );
1134
1135 provider(
1136 "user tags coexist with internal tags and can be removed",
1137 (stack) =>
1138 Effect.gen(function* () {
1139 yield* stack.destroy();
1140
1141 const withTags = yield* stack.deploy(
1142 Effect.gen(function* () {
1143 return yield* Queue("TaggedQueue", { tags: { team: "payments", env: "test" } });
1144 }),
1145 );
1146
1147 const tags1 = yield* SQS.listQueueTags({ QueueUrl: withTags.queueUrl });
1148 expect(tags1.Tags?.team).toEqual("payments");
1149 expect(tags1.Tags?.env).toEqual("test");
1150 expect(tags1.Tags?.["alchemy::id"]).toBeDefined();
1151
1152 // Remove one tag, change another.
1153 const updated = yield* stack.deploy(
1154 Effect.gen(function* () {
1155 return yield* Queue("TaggedQueue", { tags: { team: "platform" } });
1156 }),
1157 );
1158
1159 yield* Effect.gen(function* () {
1160 const tags = yield* SQS.listQueueTags({ QueueUrl: updated.queueUrl });
1161 const t = tags.Tags ?? {};
1162 if (t.team !== "platform" || t.env !== undefined) {
1163 return yield* Effect.fail(new QueueAttributesNotReady());
1164 }
1165 // internal tags survive untag.
1166 expect(t["alchemy::id"]).toBeDefined();
1167 }).pipe(
1168 Effect.retry({
1169 while: (e) => e._tag === "QueueAttributesNotReady",
1170 schedule: Schedule.spaced("2 seconds"),
1171 times: 10,
1172 }),
1173 );
1174
1175 yield* stack.destroy();
1176 yield* assertQueueDeleted(withTags.queueUrl);
1177 }),
1178 { tags: ["provider:aws", "provider:aws:sqs", "live"], timeout: 120_000 },
1179 );
1180
1181 provider(
1182 "FIFO source with FIFO dead-letter queue (no type mismatch)",
1183 (stack) =>
1184 Effect.gen(function* () {
1185 yield* stack.destroy();
1186
1187 const { source } = yield* stack.deploy(
1188 Effect.gen(function* () {
1189 const dlq = yield* Queue("FifoDLQ", { fifo: true });
1190 const source = yield* Queue("FifoSource", {
1191 fifo: true,
1192 redrivePolicy: { deadLetterTargetArn: dlq.queueArn, maxReceiveCount: 5 },
1193 });
1194 return { dlq, source };
1195 }),
1196 );
1197
1198 yield* waitForQueueAttributePredicate(source.queueUrl, (attrs) => {
1199 if (!attrs.RedrivePolicy) return false;
1200 return JSON.parse(attrs.RedrivePolicy).maxReceiveCount === 5;
1201 });
1202
1203 yield* stack.destroy();
1204 yield* assertQueueDeleted(source.queueUrl);
1205 }),
1206 { tags: ["provider:aws", "provider:aws:sqs", "live"], timeout: 120_000 },
1207 );
1208
1209 class QueueNotListed extends Data.TaggedError("QueueNotListed") {}
1210
1211 class QueueStillExists extends Data.TaggedError("QueueStillExists") {}
1212
1213 class FunctionNotReady extends Data.TaggedError("FunctionNotReady") {}
1214
1215 class QueueMessageNotReady extends Data.TaggedError("QueueMessageNotReady") {}
1216
1217 class QueueAttributesNotReady extends Data.TaggedError("QueueAttributesNotReady") {}
1218
1219 const waitForFunctionReady = (url: string) =>
1220 HttpClient.get(url).pipe(
1221 Effect.timeout("4 seconds"),
1222 Effect.mapError(() => new FunctionNotReady()),
1223 Effect.flatMap((response) =>
1224 response.status === 200
1225 ? (response.json as Effect.Effect<{ queueUrl: string }>)
1226 : Effect.fail(new FunctionNotReady()),
1227 ),
1228 // A freshly-deployed function can briefly serve a 200 before its captured
1229 // env vars (the queue URL) have finished propagating, so treat a missing
1230 // queueUrl as "not ready yet" and keep polling.
1231 Effect.flatMap((json: any) =>
1232 typeof json?.queueUrl === "string"
1233 ? Effect.succeed({ queueUrl: json.queueUrl as string })
1234 : Effect.fail(new FunctionNotReady()),
1235 ),
1236 Effect.retry({
1237 while: (error) => error._tag === "FunctionNotReady",
1238 schedule: Schedule.fixed("4 seconds"),
1239 times: 10,
1240 }),
1241 );
1242
1243 /** Poll until GetQueueAttributes reflects SetQueueAttributes (SQS is eventually consistent). */
1244 const waitForQueueAttributeMatch = Effect.fn(function* (
1245 queueUrl: string,
1246 expected: Record<string, string>,
1247 ) {
1248 yield* Effect.gen(function* () {
1249 const result = yield* SQS.getQueueAttributes({ QueueUrl: queueUrl, AttributeNames: ["All"] });
1250 const attrs = result.Attributes ?? {};
1251 for (const [name, value] of Object.entries(expected)) {
1252 if (attrs[name] !== value) {
1253 return yield* Effect.fail(new QueueAttributesNotReady());
1254 }
1255 }
1256 }).pipe(
1257 Effect.retry({
1258 // SQS is eventually consistent: a freshly-created queue can briefly
1259 // 400 with `QueueDoesNotExist` on getQueueAttributes before it settles.
1260 while: (e) => e._tag === "QueueAttributesNotReady" || e._tag === "QueueDoesNotExist",
1261 schedule: Schedule.spaced("2 seconds"),
1262 times: 10,
1263 }),
1264 );
1265 });
1266
1267 /** Poll until a predicate over the queue's attributes holds. */
1268 const waitForQueueAttributePredicate = Effect.fn(function* (
1269 queueUrl: string,
1270 predicate: (attrs: Record<string, string | undefined>) => boolean,
1271 ) {
1272 yield* Effect.gen(function* () {
1273 const result = yield* SQS.getQueueAttributes({ QueueUrl: queueUrl, AttributeNames: ["All"] });
1274 if (!predicate(result.Attributes ?? {})) {
1275 return yield* Effect.fail(new QueueAttributesNotReady());
1276 }
1277 }).pipe(
1278 Effect.retry({
1279 // See `waitForQueueAttributeMatch`: ride out the brief post-create
1280 // `QueueDoesNotExist` window as well as the predicate-not-yet-true case.
1281 while: (e) => e._tag === "QueueAttributesNotReady" || e._tag === "QueueDoesNotExist",
1282 schedule: Schedule.spaced("4 seconds"),
1283 times: 10,
1284 }),
1285 );
1286 });
1287
1288 const waitForQueuePolicy = (queueUrl: string, statements: PolicyStatement[]) =>
1289 waitForQueueAttributePredicate(
1290 queueUrl,
1291 (attrs) =>
1292 attrs.Policy !== undefined &&
1293 normalizePolicyDocument(attrs.Policy) ===
1294 normalizePolicyDocument({ Version: "2012-10-17", Statement: statements }),
1295 );
1296
1297 const waitForQueueTags = (
1298 queueUrl: string,
1299 predicate: (tags: Record<string, string | undefined>) => boolean,
1300 ) =>
1301 SQS.listQueueTags({ QueueUrl: queueUrl }).pipe(
1302 Effect.flatMap((result) =>
1303 predicate(result.Tags ?? {}) ? Effect.void : Effect.fail(new QueueAttributesNotReady()),
1304 ),
1305 Effect.retry({
1306 while: (error) =>
1307 error._tag === "QueueAttributesNotReady" || error._tag === "QueueDoesNotExist",
1308 schedule: Schedule.spaced("2 seconds"),
1309 times: 10,
1310 }),
1311 );
1312
1313 const waitForQueueMessages = Effect.fn(function* (queueUrl: string, count: number) {
1314 const messages: string[] = [];
1315
1316 while (messages.length < count) {
1317 messages.push(yield* waitForQueueMessage(queueUrl));
1318 }
1319
1320 return messages;
1321 });
1322
1323 const waitForQueueMessage = (queueUrl: string) =>
1324 Effect.gen(function* () {
1325 const result = yield* SQS.receiveMessage({
1326 QueueUrl: queueUrl,
1327 MaxNumberOfMessages: 1,
1328 WaitTimeSeconds: 2,
1329 VisibilityTimeout: 5,
1330 });
1331
1332 const message = result.Messages?.[0];
1333 if (!message?.Body || !message.ReceiptHandle) {
1334 return yield* Effect.fail(new QueueMessageNotReady());
1335 }
1336
1337 const body = message.Body;
1338
1339 yield* SQS.deleteMessage({ QueueUrl: queueUrl, ReceiptHandle: message.ReceiptHandle });
1340
1341 return body;
1342 }).pipe(
1343 Effect.retry({
1344 while: (error) => error._tag === "QueueMessageNotReady",
1345 schedule: Schedule.spaced("2 seconds"),
1346 times: 10,
1347 }),
1348 );
1349
1350 // Finalizer for adoption fixtures whose state has deliberately been removed.
1351 // #2688: `read` must observe the queue attributes and tags reconcile
1352 // converges, or an out-of-band change reads as `unchanged`.
1353 provider(
1354 "drift detects and repairs out-of-band attribute and tag changes",
1355 (stack) =>
1356 Effect.gen(function* () {
1357 yield* stack.destroy();
1358
1359 const queue = yield* stack.deploy(
1360 Queue("DriftQueue", {
1361 visibilityTimeout: "45 seconds",
1362 messageRetentionPeriod: "2 days",
1363 tags: { team: "declared" },
1364 }),
1365 );
1366 expect((yield* driftOf(stack, "DriftQueue"))?.action).toBe("unchanged");
1367
1368 yield* SQS.setQueueAttributes({
1369 QueueUrl: queue.queueUrl,
1370 Attributes: { VisibilityTimeout: "90" },
1371 });
1372 yield* SQS.tagQueue({ QueueUrl: queue.queueUrl, Tags: { team: "out-of-band" } });
1373
1374 const drifted = yield* waitForDrift(stack, "DriftQueue", "drifted");
1375 expect(drifted?.attr?.attributes?.VisibilityTimeout).toBe("90");
1376 expect(drifted?.attr?.tags?.team).toBe("out-of-band");
1377
1378 const repaired = yield* repairDrift(stack);
1379 expect(repaired.resources.DriftQueue?.action).toBe("repaired");
1380 expect((yield* waitForDrift(stack, "DriftQueue", "unchanged"))?.action).toBe("unchanged");
1381
1382 const attributes = yield* SQS.getQueueAttributes({
1383 QueueUrl: queue.queueUrl,
1384 AttributeNames: ["VisibilityTimeout"],
1385 });
1386 expect(attributes.Attributes?.VisibilityTimeout).toBe("45");
1387 const tags = yield* SQS.listQueueTags({ QueueUrl: queue.queueUrl });
1388 expect(tags.Tags?.team).toBe("declared");
1389
1390 yield* stack.destroy();
1391 yield* assertQueueDeleted(queue.queueUrl);
1392 }),
1393 { tags: ["provider:aws", "provider:aws:sqs", "live"], timeout: 180_000 },
1394 );
1395
1396 const deleteQueueIfExists = (queueName: string) =>
1397 SQS.getQueueUrl({ QueueName: queueName }).pipe(
1398 Effect.flatMap((r) =>
1399 SQS.deleteQueue({ QueueUrl: r.QueueUrl! }).pipe(
1400 Effect.andThen(assertQueueDeleted(r.QueueUrl!)),
1401 ),
1402 ),
1403 Effect.catchTag("QueueDoesNotExist", () => Effect.void),
1404 Effect.retry({
1405 while: (error) => error._tag === "RequestThrottled",
1406 schedule: Schedule.spaced("2 seconds"),
1407 times: 5,
1408 }),
1409 );
1410
1411 const assertQueueDeleted = (queueUrl: string) =>
1412 Effect.gen(function* () {
1413 const attributesAbsent = yield* SQS.getQueueAttributes({
1414 QueueUrl: queueUrl,
1415 AttributeNames: ["QueueArn"],
1416 }).pipe(
1417 Effect.as(false),
1418 Effect.catchTag("QueueDoesNotExist", () => Effect.succeed(true)),
1419 );
1420 const urlAbsent = yield* SQS.getQueueUrl({
1421 QueueName: queueUrl.slice(queueUrl.lastIndexOf("/") + 1),
1422 }).pipe(
1423 Effect.as(false),
1424 Effect.catchTag("QueueDoesNotExist", () => Effect.succeed(true)),
1425 );
1426 if (!attributesAbsent || !urlAbsent) {
1427 return yield* Effect.fail(new QueueStillExists());
1428 }
1429 }).pipe(
1430 Effect.retry({
1431 while: (error) => error._tag === "QueueStillExists",
1432 schedule: Schedule.spaced("6 seconds"),
1433 times: 10,
1434 }),
1435 );