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

import * as AWS from "@alchemy.run/aws";
import { AWSEnvironment } from "@alchemy.run/aws/Environment";
import { expect, it } from "@alchemy.run/test";
import * as Test from "@alchemy.run/test/Alchemy";
import * as s3 from "@distilled.cloud/aws/s3";
import * as NodeServices from "@effect/platform-node/NodeServices";
import { AlchemyContext } from "alchemy/AlchemyContext";
import { ArtifactStore, createArtifactStore } from "alchemy/Artifacts";
import { AuthProvidersLive } from "alchemy/Auth/AuthProvider";
import { ProfileStoreLive } from "alchemy/Auth/Profile";
import { Stack } from "alchemy/Stack";
import { Stage } from "alchemy/Stage";
import { State, type ResourceState } from "alchemy/State";
import * as ConfigProvider from "effect/ConfigProvider";
import * as Effect from "effect/Effect";
import * as FetchHttpClient from "effect/http/FetchHttpClient";
import * as Layer from "effect/Layer";
import * as Result from "effect/Result";
import { v4 as uuidv4 } from "uuid";

it.live(
  "building the AWS provider layers rejects an unknown explicit profile",
  () =>
    Effect.gen(function* () {
      // AWSEnvironment is constructed lazily so `alchemy dev` can build
      // provider layers without credentials. The unknown-profile rejection
      // surfaces on first use, not at `Layer.build`.
      const result = yield* Effect.result(
        Effect.sandbox(AWSEnvironment.current.pipe(Effect.provide(AWS.providers()))),
      );
      expect(Result.isFailure(result)).toBe(true);
      if (Result.isFailure(result)) {
        expect(String(result.failure)).toContain("does not exist");
        expect(String(result.failure)).toContain("alchemy profile create");
      }
    }).pipe(
      Effect.provide(
        Layer.mergeAll(
          AuthProvidersLive,
          Layer.sync(ArtifactStore, createArtifactStore),
          Layer.succeed(Stage, "test"),
          Layer.succeed(Stack, {
            name: "test",
            stage: "test",
            resources: {},
            bindings: {},
            actions: {},
          }),
          Layer.succeed(AlchemyContext, { dev: false, adopt: false, dotAlchemy: ".alchemy" }),
          ConfigProvider.layer(
            ConfigProvider.fromUnknown({ ALCHEMY_PROFILE: `non-existent-${uuidv4()}` }),
          ),
          ProfileStoreLive,
        ).pipe(Layer.provideMerge(Layer.mergeAll(NodeServices.layer, FetchHttpClient.layer))),
      ),
    ),
  { tags: ["unit", "provider:aws", "local"] },
);

// The profile's own environment, moved to another region. Providing it to
// `AWS.providers()` / `AWS.state()` from outside must win over the built-in
// profile default — the region makes it observable.
const PROVIDED_REGION = "us-east-2";
const providedEnvironment = Layer.effect(
  AWSEnvironment,
  Effect.gen(function* () {
    const profileEnvironment = yield* AWSEnvironment;
    return Effect.map(profileEnvironment, (environment) => ({
      ...environment,
      region: PROVIDED_REGION,
    }));
  }),
).pipe(Layer.provide(AWS.providers()));

const provided = Test.make({
  providers: AWS.providers().pipe(Layer.provide(providedEnvironment)),
});

provided.test.provider(
  "a provided AWSEnvironment drives providers() and state()",
  (stack) =>
    Effect.gen(function* () {
      yield* stack.destroy();

      // Resources deploy with the provided environment.
      const bucket = yield* stack.deploy(
        AWS.S3.Bucket("ProvidedEnvironmentBucket", { forceDestroy: true }),
      );
      expect(bucket.region).toBe(PROVIDED_REGION);
      const location = yield* s3.getBucketLocation({ Bucket: bucket.bucketName });
      expect(location.LocationConstraint).toBe(PROVIDED_REGION);

      // The state store uses the same provided environment: a round-trip
      // against the bucket in that region.
      const state = yield* (yield* State).pipe(
        Effect.provide(
          AWS.state({ bucketName: bucket.bucketName, prefix: "provided-environment" }).pipe(
            Layer.provide(providedEnvironment),
          ),
        ),
      );
      const row = {
        resourceType: "test:resource",
        namespace: undefined,
        fqn: "Provided",
        logicalId: "Provided",
        instanceId: "instance-provided",
        providerVersion: 1,
        status: "created",
        downstream: [],
        bindings: [],
        props: {},
        attr: { value: "provided" },
      } as unknown as ResourceState;
      const key = { stack: "ProvidedEnvironmentStack", stage: "provided" };
      yield* state.set({ ...key, fqn: row.fqn, value: row });
      expect(yield* state.get({ ...key, fqn: row.fqn })).toEqual(row);
      yield* state.deleteStack(key);

      yield* stack.destroy();
    }),
  {
    tags: ["provider:aws", "provider:aws:s3", "provider:aws:statestore", "live"],
    timeout: 180_000,
  },
);