Add integration tests for DynamoDB Local and support custom endpoint configuration

m-houston · m-houston · commit 1f2a4bde1686 · 2026-03-03T14:55:05.000Z
diff --git a/.github/workflows/stage-2-test.yaml b/.github/workflows/stage-2-test.yaml
@@ -152,3 +152,19 @@ jobs:
           sonar_organisation_key: "${{ vars.SONAR_ORGANISATION_KEY }}"
           sonar_project_key: "${{ vars.SONAR_PROJECT_KEY }}"
           sonar_token: "${{ secrets.SONAR_TOKEN }}"
+  test-integration:
+    name: "Integration tests"
+    runs-on: ubuntu-latest
+    timeout-minutes: 10
+    steps:
+      - name: "Checkout code"
+        uses: actions/checkout@v4
+      - name: "Repo setup"
+        run: |
+          npm ci
+      - name: "Generate dependencies"
+        run: |
+          npm run generate-dependencies --workspaces --if-present
+      - name: "Run workspace integration tests"
+        run: |
+          npm run test:integration --workspaces --if-present
diff --git a/packages/ddb-publisher/jest.config.ts b/packages/ddb-publisher/jest.config.ts
@@ -41,6 +41,7 @@ const config: Config = {
 
   testEnvironment: "node",
   testMatch: ["**/__tests__/**/*.ts", "**/?(*.)+(spec|test).ts"],
+  testPathIgnorePatterns: ["/__integration__/"],
   moduleFileExtensions: ["ts", "js", "json", "node"],
 
   transform: {
diff --git a/packages/ddb-publisher/jest.integration.config.ts b/packages/ddb-publisher/jest.integration.config.ts
@@ -0,0 +1,23 @@
+import type { Config } from "jest";
+
+const config: Config = {
+  preset: "ts-jest",
+  clearMocks: true,
+  collectCoverage: false,
+  testEnvironment: "node",
+  testMatch: ["**/__integration__/**/*.test.ts"],
+  moduleFileExtensions: ["ts", "js", "json", "node"],
+  testTimeout: 120_000,
+  transform: {
+    "^.+\\.ts$": [
+      "ts-jest",
+      {
+        tsconfig: {
+          module: "CommonJS",
+        },
+      },
+    ],
+  },
+};
+
+export default config;
diff --git a/packages/ddb-publisher/package.json b/packages/ddb-publisher/package.json
@@ -27,6 +27,7 @@
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
     "start": "tsx src/cli.ts",
+    "test:integration": "jest --config jest.integration.config.ts --runInBand",
     "test:unit": "jest",
     "typecheck": "tsc --noEmit"
   },
diff --git a/packages/ddb-publisher/src/__integration__/publish-action.integration.test.ts b/packages/ddb-publisher/src/__integration__/publish-action.integration.test.ts
@@ -0,0 +1,240 @@
+import { mkdtemp, mkdir, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join, resolve } from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+
+import {
+  CreateTableCommand,
+  DynamoDBClient,
+  ListTablesCommand,
+  ScanCommand,
+  waitUntilTableExists,
+} from "@aws-sdk/client-dynamodb";
+
+const execFileAsync = promisify(execFile);
+
+const repoRoot = resolve(__dirname, "../../../..");
+
+let containerName = "";
+let endpointUrl = "";
+let dockerAvailable = true;
+
+async function run(
+  command: string,
+  args: string[],
+  cwd = repoRoot,
+  env: NodeJS.ProcessEnv = process.env,
+): Promise<{ stdout: string; stderr: string }> {
+  return execFileAsync(command, args, {
+    cwd,
+    env,
+  });
+}
+
+async function startDdbLocal(): Promise<void> {
+  containerName = `ddb-publisher-it-${Date.now()}-${Math.floor(Math.random() * 10_000)}`;
+
+  try {
+    await run("docker", ["version"]);
+  } catch {
+    dockerAvailable = false;
+    return;
+  }
+
+  await run("docker", [
+    "run",
+    "-d",
+    "--name",
+    containerName,
+    "-p",
+    "0:8000",
+    "amazon/dynamodb-local:latest",
+    "-jar",
+    "DynamoDBLocal.jar",
+    "-inMemory",
+    "-sharedDb",
+  ]);
+
+  const portResult = await run("docker", ["port", containerName, "8000/tcp"]);
+  const mapping = portResult.stdout.trim();
+  const hostPort = mapping.split(":").at(-1);
+
+  if (!hostPort) {
+    throw new Error(`Unable to parse docker port mapping from '${mapping}'.`);
+  }
+
+  endpointUrl = `http://127.0.0.1:${hostPort}`;
+
+  const client = new DynamoDBClient({
+    endpoint: endpointUrl,
+    region: "eu-west-2",
+    credentials: {
+      accessKeyId: "local",
+      secretAccessKey: "local",
+    },
+  });
+
+  // Wait for local DynamoDB to be ready before issuing create-table.
+  for (let attempt = 0; attempt < 30; attempt += 1) {
+    try {
+      await client.send(new ListTablesCommand({ Limit: 1 }));
+      break;
+    } catch (error) {
+      if (attempt === 29) {
+        throw error;
+      }
+
+      await new Promise((resolveWait) => {
+        setTimeout(resolveWait, 250);
+      });
+    }
+  }
+
+  await client.send(
+    new CreateTableCommand({
+      TableName: "supplier-config-it",
+      BillingMode: "PAY_PER_REQUEST",
+      KeySchema: [
+        { AttributeName: "pk", KeyType: "HASH" },
+        { AttributeName: "sk", KeyType: "RANGE" },
+      ],
+      AttributeDefinitions: [
+        { AttributeName: "pk", AttributeType: "S" },
+        { AttributeName: "sk", AttributeType: "S" },
+      ],
+    }),
+  );
+
+  await waitUntilTableExists(
+    { client, maxWaitTime: 60 },
+    { TableName: "supplier-config-it" },
+  );
+}
+
+async function stopDdbLocal(): Promise<void> {
+  if (!dockerAvailable || !containerName) return;
+
+  try {
+    await run("docker", ["rm", "-f", containerName]);
+  } catch {
+    // Best-effort cleanup.
+  }
+}
+
+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",
+    },
+  };
+}
+
+describe("publish action integration (DynamoDB Local)", () => {
+  beforeAll(async () => {
+    await startDdbLocal();
+  });
+
+  afterAll(async () => {
+    await stopDdbLocal();
+  });
+
+  it("publishes records via the bundled action runtime into local DynamoDB", async () => {
+    if (!dockerAvailable) {
+      // eslint-disable-next-line no-console
+      console.warn("Docker is not available; skipping DynamoDB Local integration test.");
+      return;
+    }
+
+    const tempRoot = await mkdtemp(join(tmpdir(), "ddb-publish-config-"));
+
+    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",
+      );
+
+      // Build the same bundle that the GitHub Action downloads and executes.
+      await run("npm", [
+        "run",
+        "bundle:release",
+        "--workspace",
+        "@supplier-config/ddb-publisher",
+      ]);
+
+      const bundlePath = join(
+        repoRoot,
+        "packages/ddb-publisher/artifacts/ddb-publish/index.cjs",
+      );
+
+      await run(
+        "node",
+        [
+          bundlePath,
+          "--source",
+          tempRoot,
+          "--env",
+          "draft",
+          "--table",
+          "supplier-config-it",
+        ],
+        repoRoot,
+        {
+          ...process.env,
+          SUPPLIER_CONFIG_DDB_ENDPOINT_URL: endpointUrl,
+          AWS_ACCESS_KEY_ID: "local",
+          AWS_SECRET_ACCESS_KEY: "local",
+          AWS_REGION: "eu-west-2",
+        },
+      );
+
+      const verifyClient = new DynamoDBClient({
+        endpoint: endpointUrl,
+        region: "eu-west-2",
+        credentials: {
+          accessKeyId: "local",
+          secretAccessKey: "local",
+        },
+      });
+
+      const scanned = await verifyClient.send(
+        new ScanCommand({
+          TableName: "supplier-config-it",
+        }),
+      );
+
+      expect(scanned.Items).toBeDefined();
+      expect(scanned.Items).toHaveLength(1);
+
+      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 });
+    }
+  });
+});
diff --git a/packages/ddb-publisher/src/__tests__/run.test.ts b/packages/ddb-publisher/src/__tests__/run.test.ts
@@ -51,6 +51,10 @@ const publish = jest.requireMock("../ddb/publish") as unknown as {
   publishRecords: jest.Mock;
 };
 
+const awsClient = jest.requireMock("@aws-sdk/client-dynamodb") as unknown as {
+  DynamoDBClient: jest.Mock;
+};
+
 describe("runPublisher", () => {
   it("should stop after validation when dryRun=true", async () => {
     const store: LoadedConfigStore = { rootPath: "/tmp", records: [] };
@@ -218,4 +222,33 @@ describe("runPublisher", () => {
 
     writeSpy.mockRestore();
   });
+
+  it("should pass custom endpoint to DynamoDB client when env override is set", async () => {
+    const store: LoadedConfigStore = {
+      rootPath: "/tmp",
+      records: [],
+    };
+
+    fileStore.loadConfigStore.mockResolvedValue(store);
+    fileStore.validateConfigStore.mockReturnValue({ ok: true, issues: [] });
+    audit.auditBeforeLoad.mockResolvedValue({ blocking: [] });
+
+    process.env.SUPPLIER_CONFIG_DDB_ENDPOINT_URL = "http://127.0.0.1:8000";
+
+    try {
+      await runPublisher({
+        sourcePath: "/tmp",
+        env: "draft",
+        tableName: "tbl",
+        dryRun: false,
+        force: false,
+      });
+
+      expect(awsClient.DynamoDBClient).toHaveBeenCalledWith({
+        endpoint: "http://127.0.0.1:8000",
+      });
+    } finally {
+      delete process.env.SUPPLIER_CONFIG_DDB_ENDPOINT_URL;
+    }
+  });
 });
diff --git a/packages/ddb-publisher/src/run.ts b/packages/ddb-publisher/src/run.ts
@@ -72,8 +72,16 @@ async function runPublisher(plan: LoadPlan): Promise<void> {
     return;
   }
 
+  const endpointOverride = process.env.SUPPLIER_CONFIG_DDB_ENDPOINT_URL;
+
+  if (endpointOverride) {
+    logStep(`Using custom DynamoDB endpoint '${endpointOverride}'.`);
+  }
+
   logStep("Initialising DynamoDB client...");
-  const client = new DynamoDBClient({});
+  const client = new DynamoDBClient({
+    endpoint: endpointOverride,
+  });
   const ddb = DynamoDBDocumentClient.from(client, {
     marshallOptions: {
       removeUndefinedValues: true,
