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

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

import {
  addFakeResource,
  createMockAppService,
  createMockEngine,
  DEFAULT_SEED,
  reserveResource,
} from "../mocks/engine";
import { type Engine } from "@xo-cash/engine";
import { p2pkhTemplate } from "../mocks/template-p2pkh";
import { AppService } from "../../../src/services/app";

import { handleResourceCommand } from "../../../src/cli/commands/resource";
import { CommandError } from "../../../src/cli/commands/types";
import {
  createCommandDeps,
  createMockIO,
  expectLogs,
  type LogExpectation,
} from "../mocks/command";

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

const testCases: TestCase[] = [
  // List commands (no resources in empty wallet)
  {
    name: "list returns empty count when no resources",
    inputs: ["list"],
    shouldThrow: false,
    expectedData: {
      count: 0,
    },
    logs: [{ out: "No resources found" }],
  },
  {
    name: "list reserved returns empty count when no reserved resources",
    inputs: ["list", "reserved"],
    shouldThrow: false,
    expectedData: {
      count: 0,
    },
    logs: [{ out: "No resources found" }],
  },
  {
    name: "list all returns empty count when no resources",
    inputs: ["list", "all"],
    shouldThrow: false,
    expectedData: {
      count: 0,
    },
    logs: [{ out: "No resources found" }],
  },
  // Unreserve-all with no resources
  {
    name: "unreserve-all returns zero count when no reserved resources",
    inputs: ["unreserve-all"],
    shouldThrow: false,
    expectedData: {
      count: 0,
    },
    logs: [{ out: "No reserved resources" }],
  },
  // Error cases
  {
    name: "throws when no subcommand provided",
    inputs: [],
    shouldThrow: true,
    expectedEvent: "resource.subcommand.missing",
  },
  {
    name: "throws when unknown subcommand provided",
    inputs: ["unknown-subcommand"],
    shouldThrow: true,
    expectedEvent: "resource.subcommand.unknown",
  },
  {
    name: "throws when unreserve called without outpoint",
    inputs: ["unreserve"],
    shouldThrow: true,
    expectedEvent: "resource.unreserve.outpoint_missing",
  },
  {
    name: "throws when unreserve called with invalid outpoint format (no colon)",
    inputs: ["unreserve", "invalid-outpoint"],
    shouldThrow: true,
    expectedEvent: "resource.unreserve.outpoint_invalid",
  },
  {
    name: "throws when unreserve called with invalid outpoint format (no vout)",
    inputs: ["unreserve", "abc123:"],
    shouldThrow: true,
    expectedEvent: "resource.unreserve.outpoint_invalid",
  },
  {
    name: "throws when unreserve called with non-existent UTXO",
    inputs: [
      "unreserve",
      "0000000000000000000000000000000000000000000000000000000000000000:0",
    ],
    shouldThrow: true,
    expectedEvent: "resource.unreserve.utxo_missing",
  },
];

describe("resource command", () => {
  let engine: Engine;
  let app: AppService;
  let tempDir: string;

  beforeEach(async () => {
    engine = await createMockEngine(DEFAULT_SEED);
    await engine.importTemplate(p2pkhTemplate);

    app = await createMockAppService(engine);

    tempDir = mkdtempSync(path.join(tmpdir(), "xo-cli-resource-tests-"));
  });

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

  test.each(testCases)(
    "$name",
    async ({
      inputs,
      options,
      shouldThrow,
      expectedEvent,
      expectedData,
      logs,
    }) => {
      const { io, spies } = createMockIO();

      if (shouldThrow) {
        try {
          await handleResourceCommand(
            createCommandDeps(app, io),
            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 handleResourceCommand(
          createCommandDeps(app, io),
          inputs,
          options ?? {},
        );
        if (expectedData) {
          Object.entries(expectedData).forEach(([key, value]) => {
            expect(result[key as keyof typeof result]).toEqual(value);
          });
        }
      }

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

describe("resource command with populated data", () => {
  let engine: Engine;
  let app: AppService;
  let tempDir: string;

  beforeEach(async () => {
    engine = await createMockEngine(DEFAULT_SEED);
    await engine.importTemplate(p2pkhTemplate);
    app = await createMockAppService(engine);
    tempDir = mkdtempSync(path.join(tmpdir(), "xo-cli-resource-tests-"));
  });

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

  test("list returns count when resources exist", async () => {
    await addFakeResource(engine, { valueSatoshis: 50000 });
    await addFakeResource(engine, { valueSatoshis: 25000 });

    const { io, spies } = createMockIO();
    const result = await handleResourceCommand(
      createCommandDeps(app, io),
      ["list"],
      {},
    );

    expect(result.count).toBe(2);
    expectLogs(spies, [{ out: "Total resources: 2" }]);
  });

  test("list shows total satoshis", async () => {
    await addFakeResource(engine, { valueSatoshis: 50000 });
    await addFakeResource(engine, { valueSatoshis: 25000 });

    const { io, spies } = createMockIO();
    await handleResourceCommand(createCommandDeps(app, io), ["list"], {});

    expectLogs(spies, [{ out: "Total satoshis: 75000" }]);
  });

  test("list excludes reserved resources by default", async () => {
    await addFakeResource(engine, { valueSatoshis: 50000 });
    await addFakeResource(engine, {
      valueSatoshis: 25000,
      reservedBy: "inv-123",
    });

    const { io } = createMockIO();
    const result = await handleResourceCommand(
      createCommandDeps(app, io),
      ["list"],
      {},
    );

    expect(result.count).toBe(1);
  });

  test("list reserved shows only reserved resources", async () => {
    await addFakeResource(engine, { valueSatoshis: 50000 });
    await addFakeResource(engine, {
      valueSatoshis: 25000,
      reservedBy: "inv-123",
    });
    await addFakeResource(engine, {
      valueSatoshis: 10000,
      reservedBy: "inv-456",
    });

    const { io, spies } = createMockIO();
    const result = await handleResourceCommand(
      createCommandDeps(app, io),
      ["list", "reserved"],
      {},
    );

    expect(result.count).toBe(2);
    expectLogs(spies, [{ out: "reserved for inv-123" }]);
  });

  test("list all shows both reserved and unreserved", async () => {
    await addFakeResource(engine, { valueSatoshis: 50000 });
    await addFakeResource(engine, {
      valueSatoshis: 25000,
      reservedBy: "inv-123",
    });

    const { io } = createMockIO();
    const result = await handleResourceCommand(
      createCommandDeps(app, io),
      ["list", "all"],
      {},
    );

    expect(result.count).toBe(2);
  });

  test("unreserve releases a reserved UTXO", async () => {
    const resource = await addFakeResource(engine, {
      valueSatoshis: 25000,
      reservedBy: "inv-123",
    });

    const { io, spies } = createMockIO();
    await handleResourceCommand(
      createCommandDeps(app, io),
      [
        "unreserve",
        `${resource.outpointTransactionHash}:${resource.outpointIndex}`,
      ],
      {},
    );

    expectLogs(spies, [
      { out: "Unreserved" },
      { out: "was reserved for inv-123" },
    ]);

    const resources = await engine.listUnspentOutputsData();
    const target = resources.find(
      (r) => r.outpointTransactionHash === resource.outpointTransactionHash,
    );
    expect(target?.reservedBy).toBeUndefined();
  });

  test("unreserve reports when UTXO is not reserved", async () => {
    const resource = await addFakeResource(engine, { valueSatoshis: 25000 });

    const { io, spies } = createMockIO();
    await handleResourceCommand(
      createCommandDeps(app, io),
      [
        "unreserve",
        `${resource.outpointTransactionHash}:${resource.outpointIndex}`,
      ],
      {},
    );

    expectLogs(spies, [{ out: "UTXO is not reserved" }]);
  });

  test("unreserve-all releases all reserved UTXOs", async () => {
    await addFakeResource(engine, { valueSatoshis: 50000 });
    await addFakeResource(engine, {
      valueSatoshis: 25000,
      reservedBy: "inv-123",
    });
    await addFakeResource(engine, {
      valueSatoshis: 10000,
      reservedBy: "inv-456",
    });

    const { io, spies } = createMockIO();
    const result = await handleResourceCommand(
      createCommandDeps(app, io),
      ["unreserve-all"],
      {},
    );

    expect(result.count).toBe(2);
    expectLogs(spies, [{ out: "Unreserved" }, { out: "2" }]);

    const resources = await engine.listUnspentOutputsData();
    const reserved = resources.filter((r) => r.reservedBy);
    expect(reserved).toHaveLength(0);
  });

  test("list displays outpoint information", async () => {
    const resource = await addFakeResource(engine, { valueSatoshis: 12345 });

    const { io, spies } = createMockIO();
    await handleResourceCommand(createCommandDeps(app, io), ["list"], {});

    expectLogs(spies, [
      { out: resource.outpointTransactionHash },
      { out: "12345 sats" },
    ]);
  });
});