sailfork / t3code-github / .repos/ alchemy-effect/ packages/ integration-tests/ test/ AWS/ SNS/ Topic.test.ts

import * as AWS from "@alchemy.run/aws";
import { AWSEnvironment } from "@alchemy.run/aws/Environment";
import { Topic } from "@alchemy.run/aws/SNS";
import { describe, expect } from "@alchemy.run/test";
import * as Test from "@alchemy.run/test/Alchemy";
import * as SNS from "@distilled.cloud/aws/sns";
import { adopt } from "alchemy/AdoptPolicy";
import * as Drift from "alchemy/Drift";
import * as Provider from "alchemy/Provider";
import { State } from "alchemy/State";
import * as Data from "effect/Data";
import * as Effect from "effect/Effect";
import * as Schedule from "effect/Schedule";

const { test } = Test.make({ providers: AWS.providers() });

// Idempotent out-of-band delete for topics that adoption tests leave
// unmanaged (state wiped) mid-test. DeleteTopic is idempotent per AWS, but
// tolerate NotFoundException defensively.
const deleteTopicIdempotent = (topicArn: string) =>
  SNS.deleteTopic({ TopicArn: topicArn }).pipe(
    Effect.catchTag("NotFoundException", () => Effect.void),
    Effect.catchTag("InvalidParameterException", () => Effect.void),
    // Best-effort out-of-band cleanup finalizer: any unexpected error is a
    // defect (surfaces a genuinely stuck delete) so the error channel is
    // `never` and this is a valid `Effect.ensuring` finalizer.
    Effect.orDie,
  );

const topicArnFor = Effect.fn(function* (topicName: string) {
  const { accountId, region } = yield* AWSEnvironment.current;
  return `arn:aws:sns:${region}:${accountId}:${topicName}`;
});

describe("AWS.SNS.Topic", { tags: ["provider:aws", "provider:aws:sns", "live"] }, () => {
  test.provider("create and delete topic with default props", (stack) =>
    Effect.gen(function* () {
      yield* stack.destroy();

      const topic = yield* stack.deploy(
        Effect.gen(function* () {
          return yield* Topic("DefaultTopic");
        }),
      );

      expect(topic.topicName).toBeDefined();
      expect(topic.topicArn).toBeDefined();

      const attributes = yield* SNS.getTopicAttributes({ TopicArn: topic.topicArn });
      expect(attributes.Attributes?.TopicArn).toBe(topic.topicArn);

      yield* stack.destroy();
      yield* assertTopicDeleted(topic.topicArn);
    }),
  );

  test.provider("create, update, delete topic attributes and tags", (stack) =>
    Effect.gen(function* () {
      yield* stack.destroy();

      const topic = yield* stack.deploy(
        Effect.gen(function* () {
          return yield* Topic("ManagedTopic", {
            attributes: { DisplayName: "managed-topic-v1" },
            tags: { env: "test" },
          });
        }),
      );

      const initialAttributes = yield* SNS.getTopicAttributes({ TopicArn: topic.topicArn });
      expect(initialAttributes.Attributes?.DisplayName).toBe("managed-topic-v1");

      // #1968: SNS-filled attributes (Policy, Owner, counters) are not drift,
      // but an out-of-band change to a declared attribute is.
      const target = { name: stack.name, stage: stack.stage };
      const clean = yield* Drift.detect(target).pipe(Effect.provide(stack.state));
      expect(clean.resources.ManagedTopic?.action).toBe("unchanged");
      yield* SNS.setTopicAttributes({
        TopicArn: topic.topicArn,
        AttributeName: "DisplayName",
        AttributeValue: "changed-out-of-band",
      });
      const drifted = yield* Drift.detect(target).pipe(Effect.provide(stack.state));
      expect(drifted.resources.ManagedTopic).toMatchObject({
        action: "drifted",
        attr: { attributes: { DisplayName: "changed-out-of-band" } },
      });

      const updatedTopic = yield* stack.deploy(
        Effect.gen(function* () {
          return yield* Topic("ManagedTopic", {
            attributes: { DisplayName: "managed-topic-v2" },
            tags: { updated: "true" },
          });
        }),
      );

      const updatedAttributes = yield* SNS.getTopicAttributes({ TopicArn: updatedTopic.topicArn });
      expect(updatedAttributes.Attributes?.DisplayName).toBe("managed-topic-v2");

      const tagResponse = yield* SNS.listTagsForResource({ ResourceArn: updatedTopic.topicArn });
      const tags = Object.fromEntries((tagResponse.Tags ?? []).map((tag) => [tag.Key, tag.Value]));
      expect(tags.updated).toBe("true");
      expect(tags.env).toBeUndefined();

      yield* stack.destroy();
      yield* assertTopicDeleted(updatedTopic.topicArn);
    }),
  );

  test.provider("create and delete fifo topic", (stack) =>
    Effect.gen(function* () {
      yield* stack.destroy();

      const topic = yield* stack.deploy(
        Effect.gen(function* () {
          return yield* Topic("FifoTopic", {
            fifo: true,
            attributes: { ContentBasedDeduplication: "true" },
          });
        }),
      );

      expect(topic.topicName).toContain(".fifo");

      const attributes = yield* SNS.getTopicAttributes({ TopicArn: topic.topicArn });
      expect(attributes.Attributes?.FifoTopic).toBe("true");
      expect(attributes.Attributes?.ContentBasedDeduplication).toBe("true");

      // #1968: SNS rejects the data protection policy read on FIFO topics;
      // that must not make the topic read as missing.
      const clean = yield* Drift.detect({ name: stack.name, stage: stack.stage }).pipe(
        Effect.provide(stack.state),
      );
      expect(clean.resources.FifoTopic?.action).toBe("unchanged");

      yield* stack.destroy();
      yield* assertTopicDeleted(topic.topicArn);
    }),
  );

  // Engine-level adoption tests for SNS Topic.
  test.provider(
    "owned topic (matching alchemy tags) is silently adopted without --adopt",
    (stack) =>
      Effect.gen(function* () {
        yield* stack.destroy();

        // Deterministic name so a re-run reclaims any orphan from a
        // previously-killed run instead of creating a new one.
        const topicName = "alchemy-test-sns-adopt";
        const topicArn = yield* topicArnFor(topicName);

        // Pre-clean: reclaim a leftover unmanaged topic from a prior run.
        yield* deleteTopicIdempotent(topicArn);

        yield* Effect.gen(function* () {
          const initial = yield* stack.deploy(
            Effect.gen(function* () {
              return yield* Topic("AdoptableTopic", { topicName });
            }),
          );
          expect(initial.topicName).toEqual(topicName);

          // Wipe state — the topic stays in SNS (unmanaged from here until
          // the re-deploy below adopts it; the ensuring below covers that
          // window on failure/interruption).
          yield* Effect.gen(function* () {
            const state = yield* yield* State;
            yield* state.delete({ stack: stack.name, stage: stack.stage, fqn: "AdoptableTopic" });
          }).pipe(Effect.provide(stack.state));

          const adopted = yield* stack.deploy(
            Effect.gen(function* () {
              return yield* Topic("AdoptableTopic", { topicName });
            }),
          );

          expect(adopted.topicArn).toEqual(initial.topicArn);

          yield* stack.destroy();
          yield* assertTopicDeleted(initial.topicArn);
        }).pipe(Effect.ensuring(deleteTopicIdempotent(topicArn)));
      }),
  );

  test.provider("foreign-tagged topic requires adopt(true) to take over", (stack) =>
    Effect.gen(function* () {
      yield* stack.destroy();

      // Deterministic name so a re-run reclaims any orphan from a
      // previously-killed run instead of creating a new one.
      const topicName = "alchemy-test-sns-takeover";
      const topicArn = yield* topicArnFor(topicName);

      // Pre-clean: reclaim a leftover unmanaged topic from a prior run.
      yield* deleteTopicIdempotent(topicArn);

      yield* Effect.gen(function* () {
        const original = yield* stack.deploy(
          Effect.gen(function* () {
            return yield* Topic("Original", { topicName });
          }),
        );

        yield* Effect.gen(function* () {
          const state = yield* yield* State;
          yield* state.delete({ stack: stack.name, stage: stack.stage, fqn: "Original" });
        }).pipe(Effect.provide(stack.state));

        const takenOver = yield* stack
          .deploy(
            Effect.gen(function* () {
              return yield* Topic("Different", { topicName });
            }),
          )
          .pipe(adopt(true));

        expect(takenOver.topicArn).toEqual(original.topicArn);

        const tagsResp = yield* SNS.listTagsForResource({ ResourceArn: takenOver.topicArn });
        const tagMap = Object.fromEntries(
          (tagsResp.Tags ?? [])
            .filter((t): t is { Key: string; Value: string } => typeof t.Value === "string")
            .map((t) => [t.Key, t.Value]),
        );
        expect(tagMap["alchemy::id"]).toEqual("Different");

        yield* stack.destroy();
        yield* assertTopicDeleted(takenOver.topicArn);
      }).pipe(Effect.ensuring(deleteTopicIdempotent(topicArn)));
    }),
  );

  // Canonical `list()` test (AWS account/region-scoped collection): deploy a
  // real topic, resolve the provider from context via the typed
  // `Provider.findProvider`, call `list()`, and assert the deployed topic
  // appears in the exhaustively-paginated result.
  test.provider("list enumerates the deployed topic", (stack) =>
    Effect.gen(function* () {
      yield* stack.destroy();

      const topic = yield* stack.deploy(
        Effect.gen(function* () {
          return yield* Topic("ListTopic", { topicName: "alchemy-test-sns-topic-list" });
        }),
      );

      const provider = yield* Provider.findProvider(Topic);
      const all = yield* provider.list();

      expect(all.some((t) => t.topicArn === topic.topicArn)).toBe(true);

      yield* stack.destroy();
      yield* assertTopicDeleted(topic.topicArn);
    }),
  );

  class TopicStillExists extends Data.TaggedError("TopicStillExists") {}

  const assertTopicDeleted = Effect.fn(function* (topicArn: string) {
    yield* SNS.getTopicAttributes({ TopicArn: topicArn }).pipe(
      Effect.flatMap(() => Effect.fail(new TopicStillExists())),
      Effect.retry({
        while: (error) => error._tag === "TopicStillExists",
        schedule: Schedule.exponential(100),
        times: 8,
      }),
      Effect.catchTag("NotFoundException", () => Effect.void),
      Effect.catchTag("InvalidParameterException", () => Effect.void),
    );
  });
});