xo-cli/tests/cli/commands/mnemonic.test.ts

import { expect, test, describe, beforeEach, afterEach } from "vitest";
import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
import { tmpdir } from "node:os";
import path from "node:path";

import { DEFAULT_SEED } from "../mocks/engine";

import { handleMnemonicCommand } from "../../../src/cli/commands/mnemonic";
import { CommandError } from "../../../src/cli/commands/types";
import { createMockIO, createMockPaths, expectLogs, type LogExpectation } from "../mocks/command";
import { BCHMnemonicURL } from "../../../src/utils/bch-mnemonic-url";

type TestCase = {
  inputs: string[];
  options?: Record<string, string>;
  shouldThrow: boolean;
  expectedEvent?: string;
  expectedData?: Record<string, unknown>;
  logs?: LogExpectation[];
};

const testCases: TestCase[] = [
  // Successful creation of a mnemonic file
  {
    inputs: ["create"],
    shouldThrow: false,
    expectedData: {
      savedAs: expect.stringMatching(/^mnemonic-\w+$/),
    },
    logs: [{ out: "Mnemonic file created" }],
  },
  // Successfully creating a mnemonic file with a custom filename
  {
    inputs: ["create"],
    options: { output: "custom-filename" },
    shouldThrow: false,
    expectedData: {
      savedAs: "custom-filename",
    },
    logs: [{ out: "custom-filename" }],
  },
  // Successfully listing mnemonic files
  {
    inputs: ["list"],
    shouldThrow: false,
    expectedData: {
      count: expect.toSatisfy((count: number) => count >= 1),
    },
    logs: [{ out: "mnemonic-test" }],
  },
  // Successfully exposing a mnemonic file
  {
    inputs: ["expose", "mnemonic-test"],
    shouldThrow: false,
    expectedData: {
      mnemonic: DEFAULT_SEED,
    },
    logs: [{ out: DEFAULT_SEED }],
  },
  // Successfully importing a mnemonic file
  {
    inputs: ["import", ...DEFAULT_SEED.split(" ")],
    shouldThrow: false,
    expectedData: {
      savedAs: expect.stringMatching(/^mnemonic-\w+$/),
    },
    logs: [{ out: "Mnemonic file created" }],
  },
  // Failure to import a mnemonic file due to missing arguments
  {
    inputs: ["import"],
    shouldThrow: true,
    expectedEvent: "mnemonic.import.seed_missing",
  },
  // Failure to expose a mnemonic file due to missing arguments
  {
    inputs: ["expose"],
    shouldThrow: true,
    expectedEvent: "mnemonic.expose.file_missing",
  },
  // Failure to expose a mnemonic file due to unknown mnemonic file
  {
    inputs: ["expose", "unknown-mnemonic-file"],
    shouldThrow: true,
    expectedEvent: "mnemonic.expose.file_not_found",
  },
  // Missing sub-command
  {
    inputs: [],
    shouldThrow: true,
    expectedEvent: "mnemonic.subcommand.missing",
  },
  // Unknown sub-command
  {
    inputs: ["unknown"],
    shouldThrow: true,
    expectedEvent: "mnemonic.subcommand.unknown",
  },
];

describe("mnemonic commands", () => {
  let tempDir: string;

  beforeEach(async () => {
    tempDir = mkdtempSync(path.join(tmpdir(), "xo-cli-mnemonic-tests-"));
    
    // Write a single test mnemonic file to the temp directory
    writeFileSync(
      path.join(tempDir, "mnemonic-test"),
      BCHMnemonicURL.fromSeed(DEFAULT_SEED).toURL(),
      "utf8",
    );
  });

  afterEach(async () => {
    rmSync(tempDir, { recursive: true, force: true });
  });

  test.each(testCases)("mnemonic command: $inputs", async ({ inputs, options, shouldThrow, expectedEvent, expectedData, logs }) => {
    const { io, spies } = createMockIO();
    const paths = createMockPaths(tempDir);

    if (shouldThrow) {
      try {
        await handleMnemonicCommand({ io, paths }, inputs, options ?? {});
        expect.fail("Expected command to throw");
      } catch (error) {
        if (expectedEvent) {
          expect(error).toBeInstanceOf(CommandError);
          expect((error as CommandError).event).toBe(expectedEvent);
        }
      }
    } else {
      const result = await handleMnemonicCommand({ io, paths }, inputs, options ?? {});
      if (expectedData) {
        Object.entries(expectedData).forEach(([key, value]) => {
          expect(result[key as keyof typeof result]).toEqual(value);
        });
      }
    }

    if (logs) {
      expectLogs(spies, logs);
    }
  });
});