sailfork / t3code-github / .repos/ alchemy-effect/ packages/ integration-tests/ test/ AWS/ IAM/ OpenIDConnectProvider.test.ts

import * as AWS from "@alchemy.run/aws";
import { OpenIDConnectProvider } from "@alchemy.run/aws/IAM";
import { describe, expect } from "@alchemy.run/test";
import * as Test from "@alchemy.run/test/Alchemy";
import * as IAM from "@distilled.cloud/aws/iam";
import * as Provider from "alchemy/Provider";
import { isResourceState, State, type ResourceState } from "alchemy/State";
import * as Effect from "effect/Effect";
import { testOidcListUrl, testOidcThumbprintA } from "./fixtures.ts";

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

// A distinct issuer URL for the #736 recovery test — the OIDC provider ARN is
// deterministic from the URL, so sharing a URL with another test would make
// two tests provision (and tear down) the same physical provider.
const testOidcWedgedUrl = "https://example.com/alchemy-oidc-wedged";

describe(
  "AWS.IAM.OpenIDConnectProvider",
  { tags: ["provider:aws", "provider:aws:iam", "live"] },
  () => {
    test.provider("list enumerates the deployed OpenID Connect provider", (stack) =>
      Effect.gen(function* () {
        yield* stack.destroy();

        const deployed = yield* stack.deploy(
          Effect.gen(function* () {
            return yield* OpenIDConnectProvider("ListOidcProvider", {
              url: testOidcListUrl,
              clientIDList: ["sts.amazonaws.com"],
              thumbprintList: [testOidcThumbprintA],
              tags: { env: "test" },
            });
          }),
        );

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

        expect(
          all.some((p) => p.openIDConnectProviderArn === deployed.openIDConnectProviderArn),
        ).toBe(true);

        const found = all.find(
          (p) => p.openIDConnectProviderArn === deployed.openIDConnectProviderArn,
        );
        expect(found?.url).toBe(testOidcListUrl.replace(/^https?:\/\//, ""));
        expect(found?.clientIDList ?? []).toContain("sts.amazonaws.com");

        yield* stack.destroy();

        const deleted = yield* IAM.getOpenIDConnectProvider({
          OpenIDConnectProviderArn: deployed.openIDConnectProviderArn,
        }).pipe(Effect.option);
        expect(deleted._tag).toBe("None");
      }),
    );

    test.provider(
      "recovers a half-created provider whose creating-state lost Output-valued props (#736)",
      (stack) =>
        Effect.gen(function* () {
          yield* stack.destroy();

          const deployProvider = () =>
            stack.deploy(
              Effect.gen(function* () {
                return yield* OpenIDConnectProvider("WedgedOidcProvider", {
                  url: testOidcWedgedUrl,
                  clientIDList: ["sts.amazonaws.com"],
                  thumbprintList: [testOidcThumbprintA],
                });
              }),
            );

          const created = yield* deployProvider();

          // Rewrite the provider's persisted row into the wedged shape an
          // interrupted deploy leaves behind: `creating`, no attributes, and
          // the Output-valued `url` prop lost in the round-trip.
          const state = yield* yield* State;
          const stage = stack.stage;
          const fqns = yield* state.list({ stack: stack.name, stage });
          const rows = yield* Effect.forEach(fqns, (fqn) =>
            state.get({ stack: stack.name, stage, fqn }).pipe(Effect.map((row) => ({ fqn, row }))),
          );
          const wedged = rows.find(
            (r): r is { fqn: string; row: ResourceState } =>
              isResourceState(r.row) && r.row.resourceType === "AWS.IAM.OpenIDConnectProvider",
          );
          if (!wedged) {
            return yield* Effect.die(
              new Error("no AWS.IAM.OpenIDConnectProvider state row found after deploy"),
            );
          }
          yield* state.set({
            stack: stack.name,
            stage,
            fqn: wedged.fqn,
            value: {
              ...wedged.row,
              status: "creating",
              attr: undefined,
              props: { ...wedged.row.props, url: undefined },
            },
          });

          // Before the fix this crashed in `read` with
          // `TypeError: undefined is not an object (evaluating 'url.replace')`.
          const recovered = yield* deployProvider();
          expect(recovered.openIDConnectProviderArn).toEqual(created.openIDConnectProviderArn);
          expect(recovered.url).toEqual(created.url);

          yield* stack.destroy();

          const deleted = yield* IAM.getOpenIDConnectProvider({
            OpenIDConnectProviderArn: created.openIDConnectProviderArn,
          }).pipe(Effect.option);
          expect(deleted._tag).toBe("None");
        }),
      { timeout: 240_000 },
    );
  },
);