improve test coverage

Author: benjaminjnoack

test/src/apps/hdb/commands/coinbase/balances/coinbase-balances-handlers.test.ts

@@ -18,6 +18,9 @@ const {
   loggerErrorMock,
   logMock,
   tableMock,
+  clientQueryMock,
+  clientReleaseMock,
+  poolConnectMock,
 } = vi.hoisted(() => ({
   getToAndFromDatesMock: vi.fn(() => Promise.resolve({
     from: dateUtc({ year: 2026, month: 1, day: 1 }),
@@ -90,16 +93,19 @@ const {
     },
   ])),
   getClientMock: vi.fn(() => Promise.resolve({
-    connect: vi.fn(() => Promise.resolve({
-      query: vi.fn(() => Promise.resolve(undefined)),
-      release: vi.fn(),
-    })),
+    connect: poolConnectMock,
   })),
   loggerWarnMock: vi.fn(),
   loggerInfoMock: vi.fn(),
   loggerErrorMock: vi.fn(),
   logMock: vi.fn(),
   tableMock: vi.fn(),
+  clientQueryMock: vi.fn(() => Promise.resolve(undefined)),
+  clientReleaseMock: vi.fn(),
+  poolConnectMock: vi.fn(() => Promise.resolve({
+    query: clientQueryMock,
+    release: clientReleaseMock,
+  })),
 }));
 
 vi.mock("../../../../../../../src/apps/hdb/commands/shared/date-range-utils.js", () => ({
@@ -185,6 +191,16 @@ describe("hdb coinbase balance handlers", () => {
     expect(logMock.mock.calls[0]?.[0]).toContain("\"filters\"");
   });
 
+  it("prints current snapshot balances as json with current-balance metadata", async () => {
+    await coinbaseBalancesBatch({ current: true, remote: true, json: true, raw: true });
+
+    expect(requestAccountsMock).toHaveBeenCalledTimes(1);
+    expect(tableMock).not.toHaveBeenCalled();
+    expect(logMock.mock.calls[0]?.[0]).toContain("\"mode\": \"snapshot\"");
+    expect(logMock.mock.calls[0]?.[0]).toContain("\"includesCurrentBalance\": true");
+    expect(logMock.mock.calls[0]?.[0]).toContain("\"raw\": true");
+  });
+
   it("queries batch snapshot and trace", async () => {
     await coinbaseBalancesBatch({ quiet: false, raw: true });
     await coinbaseBalancesTrace("eth2", { quiet: false, raw: true });
@@ -196,6 +212,24 @@ describe("hdb coinbase balance handlers", () => {
     );
   });
 
+  it("warns when list or trace lookups return no balances", async () => {
+    selectCoinbaseBalanceLedgerMock.mockResolvedValueOnce([]);
+    traceCoinbaseBalanceLedgerMock.mockResolvedValueOnce([]);
+
+    await expect(coinbaseBalances("btc", { quiet: false })).resolves.toEqual([]);
+    await expect(coinbaseBalancesTrace("btc", { quiet: false })).resolves.toEqual([]);
+
+    expect(loggerWarnMock).toHaveBeenCalledTimes(2);
+  });
+
+  it("uses drop flow when regenerating from scratch", async () => {
+    await coinbaseBalancesRegenerate({ drop: true, quiet: true });
+
+    expect(dropCoinbaseBalanceLedgerTableMock).toHaveBeenCalledTimes(1);
+    expect(createCoinbaseBalanceLedgerTableMock).toHaveBeenCalledTimes(1);
+    expect(truncateCoinbaseBalanceLedgerTableMock).not.toHaveBeenCalled();
+  });
+
   it("regenerates balance ledger and writes computed rows", async () => {
     const count = await coinbaseBalancesRegenerate({ drop: false });
 
@@ -222,4 +256,53 @@ describe("hdb coinbase balance handlers", () => {
     expect(count).toBe(5);
   });
 
+  it("supports unwrap into ETH without a negative balance", async () => {
+    selectCoinbaseTransactionsMock.mockResolvedValueOnce([
+      {
+        id: "tx-eth",
+        timestamp: dateUtc({ year: 2026, month: 1, day: 5 }),
+        type: "Unwrap",
+        asset: "ETH",
+        num_quantity: "0.25",
+        notes: "unwrap eth",
+      },
+    ]);
+
+    const count = await coinbaseBalancesRegenerate({ quiet: true });
+
+    const firstBatch = insertCoinbaseBalanceLedgerBatchMock.mock.calls[0]?.[0];
+    expect(firstBatch?.[0]?.asset).toBe("ETH");
+    expect(firstBatch?.[1]?.tx_id).toBe("tx-eth");
+    expect(firstBatch?.[1]?.balance).toBe("0.25");
+    expect(loggerErrorMock).not.toHaveBeenCalled();
+    expect(count).toBe(2);
+  });
+
+  it("rolls back and rethrows when batched inserts fail", async () => {
+    insertCoinbaseBalanceLedgerBatchMock.mockRejectedValueOnce(new Error("insert failed"));
+
+    await expect(coinbaseBalancesRegenerate({ quiet: true })).rejects.toThrow("insert failed");
+
+    expect(clientQueryMock).toHaveBeenNthCalledWith(1, "BEGIN");
+    expect(clientQueryMock).toHaveBeenNthCalledWith(2, "ROLLBACK");
+    expect(clientReleaseMock).toHaveBeenCalledTimes(1);
+  });
+
+  it("throws when a transaction quantity is invalid during regenerate", async () => {
+    selectCoinbaseTransactionsMock.mockResolvedValueOnce([
+      {
+        id: "tx-bad",
+        timestamp: dateUtc({ year: 2026, month: 1, day: 2 }),
+        type: "Buy",
+        asset: "BTC",
+        num_quantity: "not-a-number",
+        notes: "bad row",
+      },
+    ]);
+
+    await expect(coinbaseBalancesRegenerate({ quiet: true })).rejects.toThrow(
+      "Invalid transaction quantity for tx-bad: not-a-number",
+    );
+  });
+
 });

test/src/apps/hdb/commands/coinbase/transactions/coinbase-transaction-classifiers.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, it } from "vitest";
+import {
+  getAbbreviatedType,
+  getClassifierForType,
+  getSuperclassForType,
+  getTypesForClassifier,
+} from "../../../../../../../src/apps/hdb/commands/coinbase/transactions/coinbase-transaction-classifiers.js";
+
+describe("coinbase transaction classifiers", () => {
+  it("maps classifiers and superclasses to concrete transaction types", () => {
+    expect(getTypesForClassifier("trade_buy")).toEqual(["Advanced Trade Buy", "Buy"]);
+    expect(getTypesForClassifier("income")).toEqual([
+      "Staking Income",
+      "Reward Income",
+      "Subscription Rebate",
+      "Subscription Rebates (24 Hours)",
+    ]);
+  });
+
+  it("throws for an unknown classifier label", () => {
+    expect(() => getTypesForClassifier("made-up")).toThrow("Unknown classifier: made-up");
+  });
+
+  it("maps transaction types back to classifier and superclass labels", () => {
+    expect(getClassifierForType("Buy")).toBe("trade_buy");
+    expect(getSuperclassForType("Buy")).toBe("trade");
+    expect(getClassifierForType("Deposit")).toBe("transfer_in");
+    expect(getSuperclassForType("Deposit")).toBe("non_taxable");
+    expect(getClassifierForType("Surprise")).toBe("unknown");
+    expect(getSuperclassForType("Surprise")).toBe("uncategorized");
+  });
+
+  it("returns abbreviations and falls back to the original type", () => {
+    expect(getAbbreviatedType("Advanced Trade Buy")).toBe("ATB");
+    expect(getAbbreviatedType("Reward Income")).toBe("RIN");
+    expect(getAbbreviatedType("Custom Type")).toBe("Custom Type");
+  });
+});

test/src/apps/hdb/commands/coinbase/transactions/coinbase-transactions-handlers.test.ts

@@ -256,6 +256,10 @@ describe("hdb coinbase transaction handlers", () => {
     );
   });
 
+  it("requires an explicit transaction id for id lookups", async () => {
+    await expect(coinbaseTransactionsId(undefined, {})).rejects.toThrow("Must provide transaction ID(s)");
+  });
+
   it("imports statement csv rows in a transaction", async () => {
     const count = await coinbaseTransactionsStatement("/tmp/statement.csv", { normalize: true });
 
@@ -264,6 +268,26 @@ describe("hdb coinbase transaction handlers", () => {
     expect(count).toBe(2);
   });
 
+  it("rolls back statement imports when batch insertion fails", async () => {
+    const clientQueryMock = vi
+      .fn()
+      .mockResolvedValueOnce(undefined)
+      .mockResolvedValueOnce(undefined);
+    const releaseMock = vi.fn();
+    getClientMock.mockResolvedValueOnce({
+      connect: vi.fn(() => Promise.resolve({ query: clientQueryMock, release: releaseMock })),
+    });
+    insertCoinbaseTransactionsBatchMock.mockRejectedValueOnce(new Error("batch failed"));
+
+    await expect(coinbaseTransactionsStatement("/tmp/statement.csv", { normalize: true })).rejects.toThrow(
+      "batch failed",
+    );
+
+    expect(clientQueryMock).toHaveBeenNthCalledWith(1, "BEGIN");
+    expect(clientQueryMock).toHaveBeenNthCalledWith(2, "ROLLBACK");
+    expect(releaseMock).toHaveBeenCalledTimes(1);
+  });
+
   it("regenerates from csv directory with drop flow", async () => {
     const count = await coinbaseTransactionsRegenerate({ drop: true, normalize: true });
 
@@ -305,4 +329,24 @@ describe("hdb coinbase transaction handlers", () => {
     expect(tableMock).toHaveBeenCalledTimes(1);
     expect(pnl).toBe(5200);
   });
+
+  it("skips invalid and zero balances and warns on pricing failures during nav", async () => {
+    requestAccountsMock.mockResolvedValueOnce([
+      { currency: "USD", available_balance: { value: "100" }, hold: { value: "0" } },
+      { currency: "ETH", available_balance: { value: "0.5" }, hold: { value: "0" } },
+      { currency: "DOGE", available_balance: { value: "NaN" }, hold: { value: "0" } },
+      { currency: "ADA", available_balance: { value: "0" }, hold: { value: "0" } },
+    ]);
+    requestProductMock.mockRejectedValueOnce(new Error("market unavailable"));
+    selectCoinbaseTransactionsMock
+      .mockResolvedValueOnce([{ num_quantity: "250" }])
+      .mockResolvedValueOnce([{ num_quantity: "50" }]);
+    selectCoinbaseTransactionsGroupMock.mockResolvedValueOnce([{ fee: "1.00" }]);
+
+    const pnl = await coinbaseTransactionsNav({ remote: true, quiet: true });
+
+    expect(loggerWarnMock).toHaveBeenCalledWith("Skipping NAV pricing for ETH: market unavailable");
+    expect(tableMock).not.toHaveBeenCalled();
+    expect(pnl).toBe(-100);
+  });
 });

test/src/apps/hdb/commands/test.test.ts

@@ -0,0 +1,46 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const { getClientMock, loggerInfoMock } = vi.hoisted(() => ({
+  getClientMock: vi.fn(),
+  loggerInfoMock: vi.fn(),
+}));
+
+vi.mock("../../../../../src/apps/hdb/db/db-client.js", () => ({
+  getClient: getClientMock,
+}));
+
+vi.mock("../../../../../src/shared/log/logger.js", () => ({
+  logger: {
+    info: loggerInfoMock,
+  },
+}));
+
+import { handleTestAction } from "../../../../../src/apps/hdb/commands/test.js";
+
+describe("hdb test command", () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it("logs an ISO string when the query returns a Date", async () => {
+    const queryMock = vi.fn(() => Promise.resolve({
+      rows: [{ now: new Date("2026-01-01T00:00:00.000Z") }],
+    }));
+    getClientMock.mockResolvedValue({ query: queryMock });
+
+    await handleTestAction();
+
+    expect(queryMock).toHaveBeenCalledWith("SELECT NOW() AS now");
+    expect(loggerInfoMock).toHaveBeenCalledWith("2026-01-01T00:00:00.000Z");
+  });
+
+  it("logs the raw string when the query returns a string timestamp", async () => {
+    getClientMock.mockResolvedValue({
+      query: vi.fn(() => Promise.resolve({ rows: [{ now: "2026-01-01 00:00:00+00" }] })),
+    });
+
+    await handleTestAction();
+
+    expect(loggerInfoMock).toHaveBeenCalledWith("2026-01-01 00:00:00+00");
+  });
+});