feat(tests): enhance integration tests for DynamoDB Local and improve config store loading

Author: m-houston

.github/workflows/stage-2-test.yaml

@@ -165,6 +165,6 @@ jobs:
       - name: "Generate dependencies"
         run: |
           npm run generate-dependencies --workspaces --if-present
-      - name: "Run workspace integration tests"
+      - name: "Run integration tests"
         run: |
-          npm run test:integration --workspaces --if-present
+          npm run test:integration

package.json

@@ -56,6 +56,7 @@
     "generate-dependencies": "npm run generate-dependencies --workspaces --if-present",
     "lint": "npm run lint --workspaces",
     "lint:fix": "npm run lint:fix --workspaces",
+    "test:integration": "npm run test:integration --workspaces --if-present",
     "test:unit": "npm run test:unit --workspaces",
     "typecheck": "npm run typecheck --workspaces --if-present"
   },

packages/ddb-publisher/README.md

@@ -2,6 +2,8 @@
 
 `ddb-publisher` reads supplier config JSON files from a directory, validates them against the event schemas, audits existing records in DynamoDB, then publishes the records into the target table.
 
+It is used by the `publish-config` GitHub Action, and can also be run locally for testing and development.
+
 ## Run the publisher
 
 From this package directory:
@@ -14,6 +16,28 @@ npm run cli -- \
   --dry-run
 ```
 
+## Run the integration test
+
+From the repo root:
+
+```bash
+npm run test:integration --workspace @supplier-config/ddb-publisher
+```
+
+The test starts DynamoDB Local with Testcontainers, creates the `supplier-config-it` table, bundles the CLI, and publishes the shared example config store from `tests/example-config-store`.
+
+If you are using Colima and the test cannot start Docker correctly, retry with:
+
+```bash
+TESTCONTAINERS_RYUK_DISABLED=true npm run test:integration --workspace @supplier-config/ddb-publisher
+```
+
+If needed, you can also try:
+
+```bash
+TESTCONTAINERS_DOCKER_SOCKET_OVERRIDE=/var/run/docker.sock npm run test:integration --workspace @supplier-config/ddb-publisher
+```
+
 ## Local DynamoDB
 
 Start DynamoDB Local in Docker:

packages/ddb-publisher/src/__integration__/publish-action.integration.test.ts

@@ -1,10 +1,8 @@
-import { mkdtemp, mkdir, rm, writeFile } from "node:fs/promises";
 import { execFile } from "node:child_process";
-import { tmpdir } from "node:os";
-import { join, resolve } from "node:path";
+import { resolve } from "node:path";
 import { promisify } from "node:util";
 
-import { ScanCommand } from "@aws-sdk/client-dynamodb";
+import { PutItemCommand, ScanCommand } from "@aws-sdk/client-dynamodb";
 
 import {
   createPublisherTable,
@@ -16,7 +14,56 @@ import type { DbTestContext } from "./dynamodb-local";
 const execFileAsync = promisify(execFile);
 
 const repoRoot = resolve(__dirname, "../../../..");
+const exampleConfigStoreRoot = resolve(repoRoot, "tests/example-config-store");
+const bundlePath = resolve(
+  repoRoot,
+  "packages/ddb-publisher/artifacts/ddb-publish/index.cjs",
+);
 const tableName = "supplier-config-it";
+const expectedRecords = [
+  {
+    pk: "ENTITY#channel",
+    sk: "ID#letter",
+    entity: "channel",
+    id: "letter",
+  },
+  {
+    pk: "ENTITY#volume-group",
+    sk: "ID#vg-1",
+    entity: "volume-group",
+    id: "vg-1",
+  },
+  {
+    pk: "ENTITY#letter-variant",
+    sk: "ID#lv-1",
+    entity: "letter-variant",
+    id: "lv-1",
+  },
+  {
+    pk: "ENTITY#pack-specification",
+    sk: "ID#pack-spec-1",
+    entity: "pack-specification",
+    id: "pack-spec-1",
+  },
+  {
+    pk: "ENTITY#supplier",
+    sk: "ID#sup-1",
+    entity: "supplier",
+    id: "sup-1",
+  },
+  {
+    pk: "ENTITY#supplier-allocation",
+    sk: "ID#alloc-1",
+    entity: "supplier-allocation",
+    id: "alloc-1",
+  },
+  {
+    pk: "ENTITY#supplier-pack",
+    sk: "ID#sp-1",
+    entity: "supplier-pack",
+    id: "sp-1",
+  },
+] as const;
 
 let context: DbTestContext | null = null;
 
@@ -29,38 +76,72 @@ async function run(
   return execFileAsync(command, args, { cwd, env });
 }
 
-function mockPackSpecification(): Record<string, unknown> {
-  return {
-    id: "bau-standard-c5",
-    name: "BAU Standard Letter C5",
-    status: "PROD",
-    version: 1,
-    createdAt: "2023-01-01T00:00:00Z",
-    updatedAt: "2023-01-01T00:00:00Z",
-    billingId: "BILLING-BAU-C5-001",
-    constraints: {
-      sheets: {
-        value: 5,
-        operator: "LESS_THAN_OR_EQUAL",
-      },
-    },
-    postage: {
-      id: "ECONOMY",
-      size: "STANDARD",
-      deliveryDays: 3,
-    },
-    assembly: {
-      envelopeId: "envelope-nhs-c5-economy",
-      printColour: "BLACK",
+function activeContext(): DbTestContext {
+  if (!context) {
+    throw new Error("DynamoDB test context was not initialised.");
+  }
+
+  return context;
+}
+
+async function runBundle(extraArgs: string[] = []): Promise<{
+  stdout: string;
+  stderr: string;
+}> {
+  return run(
+    "node",
+    [
+      bundlePath,
+      "--source",
+      exampleConfigStoreRoot,
+      "--env",
+      "draft",
+      "--table",
+      tableName,
+      ...extraArgs,
+    ],
+    repoRoot,
+    {
+      ...process.env,
+      SUPPLIER_CONFIG_DDB_ENDPOINT_URL: activeContext().endpoint,
     },
-  };
+  );
+}
+
+async function scanTable() {
+  return activeContext().ddbClient.send(new ScanCommand({ TableName: tableName }));
+}
+
+function expectExpectedRecords(
+  items: NonNullable<Awaited<ReturnType<typeof scanTable>>["Items"]>,
+): void {
+  expect(items).toHaveLength(expectedRecords.length);
+
+  for (const expectedRecord of expectedRecords) {
+    const actual = items.find(
+      (item) =>
+        item.pk?.S === expectedRecord.pk
+        && item.sk?.S === expectedRecord.sk,
+    );
+
+    expect(actual).toBeDefined();
+    expect(actual?.env?.S).toBe("draft");
+    expect(actual?.entity?.S).toBe(expectedRecord.entity);
+    expect(actual?.id?.S).toBe(expectedRecord.id);
+  }
 }
 
 describe("publish action integration (DynamoDB Local)", () => {
   beforeAll(async () => {
     try {
       context = await setupDynamoDBContainer();
       await createPublisherTable(context, tableName);
+      await run("npm", [
+        "run",
+        "bundle:release",
+        "--workspace",
+        "@supplier-config/ddb-publisher",
+      ]);
     } catch (error) {
       const reason = error instanceof Error ? error.message : String(error);
       throw new Error(
@@ -91,68 +172,65 @@ describe("publish action integration (DynamoDB Local)", () => {
   });
 
   it("publishes records via the bundled action runtime into local DynamoDB", async () => {
-    if (!context) {
-      throw new Error("DynamoDB test context was not initialised.");
-    }
+    await runBundle();
+
+    const scanned = await scanTable();
+
+    expect(scanned.Items).toBeDefined();
+    expectExpectedRecords(scanned.Items ?? []);
+  });
 
-    const tempRoot = await mkdtemp(join(tmpdir(), "ddb-publish-config-"));
+  it("blocks a reload when extra active records exist, then allows it with --force", async () => {
+    await activeContext().ddbClient.send(
+      new PutItemCommand({
+        TableName: tableName,
+        Item: {
+          pk: { S: "ENTITY#supplier" },
+          sk: { S: "ID#stale-supplier" },
+          entity: { S: "supplier" },
+          id: { S: "stale-supplier" },
+          env: { S: "draft" },
+          status: { S: "DRAFT" },
+          name: { S: "Stale Supplier" },
+          channelType: { S: "LETTER" },
+          dailyCapacity: { N: "1" },
+        },
+      }),
+    );
+
+    let blocked = false;
 
     try {
-      const entityDir = join(tempRoot, "pack-specification");
-      await mkdir(entityDir, { recursive: true });
-      await writeFile(
-        join(entityDir, "bau-standard-c5.json"),
-        JSON.stringify(mockPackSpecification(), null, 2),
-        "utf8",
-      );
+      await runBundle();
+    } catch (error) {
+      blocked = true;
+      const stdout = String((error as { stdout?: string }).stdout ?? "");
+      const stderr = String((error as { stderr?: string }).stderr ?? "");
+      const combined = `${stdout}\n${stderr}`;
 
-      await run("npm", [
-        "run",
-        "bundle:release",
-        "--workspace",
-        "@supplier-config/ddb-publisher",
-      ]);
+      expect(combined).toContain("Upload blocked");
+      expect(combined).toContain("ID#stale-supplier");
+    }
 
-      const bundlePath = join(
-        repoRoot,
-        "packages/ddb-publisher/artifacts/ddb-publish/index.cjs",
-      );
+    expect(blocked).toBe(true);
 
-      await run(
-        "node",
-        [
-          bundlePath,
-          "--source",
-          tempRoot,
-          "--env",
-          "draft",
-          "--table",
-          tableName,
-        ],
-        repoRoot,
-        {
-          ...process.env,
-          SUPPLIER_CONFIG_DDB_ENDPOINT_URL: context.endpoint,
-          AWS_ACCESS_KEY_ID: "fakeMyKeyId",
-          AWS_SECRET_ACCESS_KEY: "fakeSecretAccessKey",
-          AWS_REGION: "eu-west-2",
-        },
-      );
+    await runBundle(["--force"]);
 
-      const scanned = await context.ddbClient.send(
-        new ScanCommand({ TableName: tableName }),
-      );
+    const scanned = await scanTable();
 
-      expect(scanned.Items).toBeDefined();
-      expect(scanned.Items).toHaveLength(1);
+    expect(scanned.Items).toBeDefined();
+    expect(scanned.Items).toHaveLength(expectedRecords.length + 1);
+    expectExpectedRecords(
+      (scanned.Items ?? []).filter((item) => item.sk?.S !== "ID#stale-supplier"),
+    );
 
-      const [item] = scanned.Items ?? [];
-      expect(item?.pk?.S).toBe("ENTITY#pack-specification");
-      expect(item?.sk?.S).toBe("ID#bau-standard-c5");
-      expect(item?.env?.S).toBe("draft");
-      expect(item?.entity?.S).toBe("pack-specification");
-    } finally {
-      await rm(tempRoot, { recursive: true, force: true });
-    }
+    const stale = scanned.Items?.find(
+      (item) =>
+        item.pk?.S === "ENTITY#supplier"
+        && item.sk?.S === "ID#stale-supplier",
+    );
+
+    expect(stale).toBeDefined();
+    expect(stale?.status?.S).toBe("DRAFT");
   });
 });