test(bootstrap): enhance tests for ABI artifact loading and output verification

- Added tests to verify the loading of ABI artifacts when a directory is provided.
- Improved assertions to check the captured payload and ABI path during the bootstrap process.
- Ensured that output results include the expected ABI artifacts and their configurations.
- Updated existing tests to reflect changes in the handling of allocations and ABI loading.

Author: roderik

README.md

@@ -19,6 +19,8 @@ Commands:
                              emit a Besu genesis.
   compile-genesis [options]  Merge per-account allocation ConfigMaps into a Besu
                              genesis file.
+  download-abi [options]     Download ABI ConfigMaps annotated with
+                             settlemint.com/artifact=abi into a local directory.
   help [command]             display help for command
 ```
 
@@ -39,6 +41,7 @@ Options:
   --faucet-artifact-prefix <prefix>      Prefix applied to faucet ConfigMaps and Secrets.
   -v, --validators <count>               Number of validator nodes to generate. (default: 4)
   -a, --allocations <file>               Path to a genesis allocations JSON file. (default: none)
+  --abi-directory <path>                 Directory containing ABI JSON files to publish as ConfigMaps.
   -o, --outputType <type>                Output target (screen, file, kubernetes). (default: "screen")
   --static-node-port <number>            P2P port used for static-nodes enode URIs. (default: 30303)
   --static-node-discovery-port <number>  Discovery port used for static-nodes enode URIs. (default: 30303)

src/cli/commands/bootstrap/bootstrap.abis.test.ts

@@ -0,0 +1,79 @@
+import { afterEach, beforeEach, describe, expect, test } from "bun:test";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { loadAbis } from "./bootstrap.abis.ts";
+
+let workingDirectory: string;
+
+const MISSING_DIRECTORY_REGEX = /ABI directory not found/u;
+const BROKEN_FILE_REGEX = /ABI file Broken\.json is not valid JSON/u;
+
+beforeEach(async () => {
+  workingDirectory = await mkdtemp(join(tmpdir(), "abis-"));
+});
+
+afterEach(async () => {
+  await rm(workingDirectory, { recursive: true, force: true });
+});
+
+describe("loadAbis", () => {
+  test("reads json files and normalizes configmap names", async () => {
+    const firstAbi = join(workingDirectory, "Token.json");
+    const secondAbi = join(workingDirectory, "vault.ABI.JSON");
+    await writeFile(firstAbi, JSON.stringify({ name: "Token" }));
+    await writeFile(secondAbi, JSON.stringify({ name: "Vault" }));
+
+    const abis = await loadAbis(workingDirectory);
+
+    expect(abis).toEqual([
+      {
+        configMapName: "abi-token",
+        fileName: "Token.json",
+        contents: `${JSON.stringify({ name: "Token" }, null, 2)}\n`,
+      },
+      {
+        configMapName: "abi-vault.abi",
+        fileName: "vault.ABI.JSON",
+        contents: `${JSON.stringify({ name: "Vault" }, null, 2)}\n`,
+      },
+    ]);
+  });
+
+  test("recursively reads json files", async () => {
+    const nestedDirectory = join(workingDirectory, "nested");
+    await mkdir(nestedDirectory, { recursive: true });
+    await writeFile(
+      join(nestedDirectory, "Nested.json"),
+      JSON.stringify({ name: "Nested" })
+    );
+
+    const abis = await loadAbis(workingDirectory);
+
+    expect(abis).toContainEqual({
+      configMapName: "abi-nested",
+      fileName: "Nested.json",
+      contents: `${JSON.stringify({ name: "Nested" }, null, 2)}\n`,
+    });
+  });
+
+  test("ignores non-json files", async () => {
+    await writeFile(join(workingDirectory, "README.md"), "# readme");
+
+    const abis = await loadAbis(workingDirectory);
+    expect(abis).toHaveLength(0);
+  });
+
+  test("throws when directory is missing", async () => {
+    await expect(loadAbis(join(workingDirectory, "missing"))).rejects.toThrow(
+      MISSING_DIRECTORY_REGEX
+    );
+  });
+
+  test("throws when file payload is invalid json", async () => {
+    await writeFile(join(workingDirectory, "Broken.json"), "not json");
+
+    await expect(loadAbis(workingDirectory)).rejects.toThrow(BROKEN_FILE_REGEX);
+  });
+});

src/cli/commands/bootstrap/bootstrap.abis.ts

@@ -0,0 +1,83 @@
+import { stat } from "node:fs/promises";
+import { parse } from "node:path";
+import { Glob } from "bun";
+
+const JSON_EXTENSION = ".json";
+const ABI_CONFIGMAP_PREFIX = "abi-";
+const ABI_GLOB = new Glob("**/*");
+
+type AbiArtifact = {
+  configMapName: string;
+  fileName: string;
+  contents: string;
+};
+
+const normalizeConfigMapName = (fileName: string): string => {
+  const { name } = parse(fileName);
+  const normalized = name.trim().toLowerCase();
+  if (normalized.length === 0) {
+    throw new Error(
+      "ABI filenames must contain at least one alphanumeric character."
+    );
+  }
+  return `${ABI_CONFIGMAP_PREFIX}${normalized}`;
+};
+
+const loadAbis = async (directory: string): Promise<AbiArtifact[]> => {
+  const trimmedDirectory = directory.trim();
+  if (trimmedDirectory.length === 0) {
+    throw new Error("ABI directory must be provided.");
+  }
+
+  const directoryStats = await stat(trimmedDirectory).catch(() => null);
+  if (!directoryStats) {
+    throw new Error(`ABI directory not found at ${directory}`);
+  }
+  if (!directoryStats.isDirectory()) {
+    throw new Error(`ABI path must be a directory. Received ${directory}`);
+  }
+
+  const matchedFiles: string[] = [];
+  for await (const filePath of ABI_GLOB.scan({
+    cwd: trimmedDirectory,
+    absolute: true,
+    onlyFiles: true,
+  })) {
+    if (!filePath.toLowerCase().endsWith(JSON_EXTENSION)) {
+      continue;
+    }
+    matchedFiles.push(filePath);
+  }
+
+  if (matchedFiles.length === 0) {
+    return [];
+  }
+
+  const artifacts: AbiArtifact[] = [];
+  for (const absolutePath of matchedFiles) {
+    const fileName = parse(absolutePath).base;
+    const configMapName = normalizeConfigMapName(fileName);
+
+    try {
+      const parsed = await Bun.file(absolutePath).json();
+      artifacts.push({
+        configMapName,
+        fileName,
+        contents: `${JSON.stringify(parsed, null, 2)}\n`,
+      });
+    } catch (error) {
+      throw new Error(
+        `ABI file ${fileName} is not valid JSON: ${(error as Error).message}`
+      );
+    }
+  }
+
+  artifacts.sort((left, right) =>
+    left.configMapName.localeCompare(right.configMapName)
+  );
+
+  return artifacts;
+};
+
+export type { AbiArtifact };
+export { loadAbis };

src/cli/commands/bootstrap/bootstrap.command.test.ts

@@ -136,6 +136,7 @@ describe("CLI command bootstrap", () => {
     const promptCalls: [string, number | undefined, number][] = [];
     const textPromptCalls: [string, string][] = [];
     let loadAllocationsPath: string | undefined;
+    let loadAbisPath: string | undefined;
     let outputInvocation:
       | {
           type: OutputType;
@@ -199,6 +200,10 @@ describe("CLI command bootstrap", () => {
           [expectedAddress(FAUCET_INDEX)]: { balance: "0x01" as const },
         } satisfies Record<string, BesuAllocAccount>);
       },
+      loadAbis: (path: string) => {
+        loadAbisPath = path;
+        return Promise.resolve([]);
+      },
       outputResult: async (type, payload) => {
         outputInvocation = { type, payload };
         await realOutputResult(type, payload);
@@ -225,11 +230,13 @@ describe("CLI command bootstrap", () => {
     expect(output).toContain("Static Nodes");
     expect(output).toContain(GENESIS_MARKER);
     expect(loadAllocationsPath).toBe("/tmp/alloc.json");
+    expect(loadAbisPath).toBeUndefined();
     expect(outputInvocation?.type).toBe("screen");
     expect(outputInvocation?.payload.staticNodes).toEqual([
       expectedStaticNodeUri(FIRST_VALIDATOR_INDEX),
       expectedStaticNodeUri(SECOND_VALIDATOR_INDEX),
     ]);
+    expect(outputInvocation?.payload.abiArtifacts).toEqual([]);
     expect(outputInvocation?.payload.artifactNames).toEqual({
       faucetPrefix: DEFAULT_FAUCET_PREFIX,
       validatorPrefix: DEFAULT_POD_PREFIX,
@@ -238,6 +245,57 @@ describe("CLI command bootstrap", () => {
     });
   });
 
+  test("runBootstrap loads ABI artifacts when directory provided", async () => {
+    const factory = createFactoryStub();
+    const abiArtifacts = [
+      {
+        configMapName: "abi-demo",
+        fileName: "Demo.json",
+        contents: `${JSON.stringify({ name: "Demo" }, null, 2)}\n`,
+      },
+    ];
+    let capturedPayload: OutputPayload | undefined;
+    let capturedAbiPath: string | undefined;
+
+    const deps: BootstrapDependencies = {
+      factory,
+      promptForCount: () => Promise.resolve(EXPECTED_DEFAULT_VALIDATOR),
+      promptForGenesis: async (_service, { faucetAddress }) => ({
+        algorithm: ALGORITHM.QBFT,
+        config: {
+          chainId: 1,
+          faucetWalletAddress: faucetAddress,
+          gasLimit: "0x1",
+          secondsPerBlock: 2,
+        },
+        genesis: { config: {}, extraData: "0x" } as any,
+      }),
+      promptForText: passthroughTextPrompt,
+      service: {} as any,
+      loadAllocations: () =>
+        Promise.resolve({} as Record<string, BesuAllocAccount>),
+      loadAbis: (path: string) => {
+        capturedAbiPath = path;
+        return Promise.resolve(abiArtifacts);
+      },
+      outputResult: (_type, payload) => {
+        capturedPayload = payload;
+        return Promise.resolve();
+      },
+    };
+
+    await runBootstrap(
+      {
+        abiDirectory: "  /opt/abis  ",
+        acceptDefaults: true,
+      },
+      deps
+    );
+
+    expect(capturedAbiPath).toBe("/opt/abis");
+    expect(capturedPayload?.abiArtifacts).toEqual(abiArtifacts);
+  });
+
   test("createCliCommand wires metadata", () => {
     const command = createCliCommand();
     expect(command.name()).toBe("network-bootstrapper");
@@ -278,6 +336,7 @@ describe("CLI command bootstrap", () => {
       service: {} as any,
       loadAllocations: () =>
         Promise.resolve({} satisfies Record<string, BesuAllocAccount>),
+      loadAbis: () => Promise.resolve([]),
       outputResult: async (type, payload) => {
         await realOutputResult(type, payload);
       },
@@ -345,6 +404,7 @@ describe("CLI command bootstrap", () => {
       service: {} as any,
       loadAllocations: () =>
         Promise.resolve({} satisfies Record<string, BesuAllocAccount>),
+      loadAbis: () => Promise.resolve([]),
       outputResult: (_type, payload) => {
         capturedPayload = payload;
         return Promise.resolve();
@@ -426,6 +486,7 @@ describe("CLI command bootstrap", () => {
       service: {} as any,
       loadAllocations: () =>
         Promise.resolve({} satisfies Record<string, BesuAllocAccount>),
+      loadAbis: () => Promise.resolve([]),
       outputResult: (_type, payload) => {
         capturedPayload = payload;
         return Promise.resolve();
@@ -494,6 +555,7 @@ describe("CLI command bootstrap", () => {
       service: {} as any,
       loadAllocations: () =>
         Promise.resolve({} satisfies Record<string, BesuAllocAccount>),
+      loadAbis: () => Promise.resolve([]),
       outputResult: async () => {
         // no-op for test
       },
@@ -576,6 +638,7 @@ describe("CLI command bootstrap", () => {
       service: {} as any,
       loadAllocations: () =>
         Promise.resolve({} satisfies Record<string, BesuAllocAccount>),
+      loadAbis: () => Promise.resolve([]),
       outputResult: (type) => {
         capturedOutputType = type;
         return Promise.resolve();
@@ -624,6 +687,7 @@ describe("CLI command bootstrap", () => {
     const factory = createFactoryStub();
     let promptCountInvocations = 0;
     let loadAllocationsInvoked = false;
+    let loadAbisInvoked = false;
 
     const deps: BootstrapDependencies = {
       factory,
@@ -662,6 +726,10 @@ describe("CLI command bootstrap", () => {
         loadAllocationsInvoked = true;
         return Promise.resolve({} as Record<string, BesuAllocAccount>);
       },
+      loadAbis: () => {
+        loadAbisInvoked = true;
+        return Promise.resolve([]);
+      },
       outputResult: (_type, payload) => {
         expect(payload.validators).toHaveLength(EXPECTED_DEFAULT_VALIDATOR);
         expect(payload.artifactNames).toEqual({
@@ -683,5 +751,6 @@ describe("CLI command bootstrap", () => {
 
     expect(promptCountInvocations).toBe(0);
     expect(loadAllocationsInvoked).toBe(false);
+    expect(loadAbisInvoked).toBe(false);
   });
 });