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

import * as AWS from "@alchemy.run/aws";
import { Database } from "@alchemy.run/aws/Glue";
import { expect } from "@alchemy.run/test";
import * as Test from "@alchemy.run/test/Alchemy";
import * as glue from "@distilled.cloud/aws/glue";
import * as Effect from "effect/Effect";
import { driftOf, repairDrift, waitForDrift } from "../drift.ts";

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

const getDatabase = (name: string) =>
  glue.getDatabase({ Name: name }).pipe(
    Effect.map((r) => r.Database),
    Effect.catchTag("EntityNotFoundException", () => Effect.succeed(undefined)),
  );

test.provider(
  "create, update, delete Glue database",
  (stack) =>
    Effect.gen(function* () {
      yield* stack.destroy();

      // create
      const created = yield* stack.deploy(
        Effect.gen(function* () {
          return yield* Database("AnalyticsDb", {
            description: "analytics tables",
            parameters: { classification: "parquet" },
          });
        }),
      );

      expect(created.databaseName).toBeDefined();
      expect(created.databaseArn).toContain(`:database/${created.databaseName}`);
      expect(created.catalogId).toBeDefined();

      // out-of-band verification
      const observed = yield* getDatabase(created.databaseName);
      expect(observed?.Name).toEqual(created.databaseName);
      expect(observed?.Description).toEqual("analytics tables");
      expect(observed?.Parameters?.classification).toEqual("parquet");
      // ownership markers live in the Parameters map (databases aren't taggable)
      expect(observed?.Parameters?.["alchemy::id"]).toBeDefined();

      // update: description + parameters
      const updated = yield* stack.deploy(
        Effect.gen(function* () {
          return yield* Database("AnalyticsDb", {
            description: "curated analytics tables",
            locationUri: "s3://example-bucket/analytics/",
            parameters: { classification: "json" },
          });
        }),
      );

      expect(updated.databaseName).toEqual(created.databaseName);
      const reobserved = yield* getDatabase(created.databaseName);
      expect(reobserved?.Description).toEqual("curated analytics tables");
      expect(reobserved?.LocationUri).toEqual("s3://example-bucket/analytics/");
      expect(reobserved?.Parameters?.classification).toEqual("json");

      // delete
      yield* stack.destroy();
      const gone = yield* getDatabase(created.databaseName);
      expect(gone).toBeUndefined();
    }),
  { tags: ["provider:aws", "provider:aws:glue", "live"] },
);

// #2688: `read` must observe the description, location and parameters, or
// an out-of-band change reads as `unchanged`.
test.provider(
  "drift detects and repairs out-of-band database changes",
  (stack) =>
    Effect.gen(function* () {
      yield* stack.destroy();

      const db = yield* stack.deploy(
        Database("DriftDb", {
          description: "declared",
          parameters: { classification: "parquet" },
        }),
      );
      expect((yield* driftOf(stack, "DriftDb"))?.action).toBe("unchanged");

      const observed = yield* getDatabase(db.databaseName);
      yield* glue.updateDatabase({
        Name: db.databaseName,
        DatabaseInput: {
          Name: db.databaseName,
          Description: "out-of-band",
          Parameters: { ...observed?.Parameters, classification: "json" },
        },
      });

      const drifted = yield* waitForDrift(stack, "DriftDb", "drifted");
      expect(drifted?.attr?.configuration?.description).toBe("out-of-band");

      const repaired = yield* repairDrift(stack);
      expect(repaired.resources.DriftDb?.action).toBe("repaired");
      expect((yield* driftOf(stack, "DriftDb"))?.action).toBe("unchanged");
      const restored = yield* getDatabase(db.databaseName);
      expect(restored?.Description).toBe("declared");
      expect(restored?.Parameters?.classification).toBe("parquet");

      yield* stack.destroy();
      expect(yield* getDatabase(db.databaseName)).toBeUndefined();
    }),
  { tags: ["provider:aws", "provider:aws:glue", "live"] },
);