@hoox-sh/hoox-tui 0.2.0

package/src/utils/formatters.test.ts

@@ -0,0 +1,236 @@
+/**
+ * Copyright (c) 2026 HOOX · HOOX · jango-blockchained (hoox-sh)
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * Formatters Utility Tests — Time formatting, number formatting.
+ *
+ * Sources of truth (no local mirror drift):
+ *   - formatRelativeTime / formatDuration (ms) → @hoox-sh/hoox-shared/format-time
+ *   - formatNumber, formatUptime, formatLatency, formatRequests, formatPercent
+ *     → @hoox-sh/hoox-shared formatters
+ *
+ * Uses Bun test runner.
+ */
+import { describe, it, expect } from "bun:test";
+import {
+  formatRelativeTime,
+  formatDuration,
+} from "@hoox-sh/hoox-shared/format-time";
+import {
+  formatNumber,
+  formatLatency,
+  formatRequests,
+  formatPercent,
+  formatUptime,
+  formatDurationCompact,
+} from "@hoox-sh/hoox-shared";
+
+// ─── formatRelativeTime (format-time: status bar / reconnection) ─────────────
+
+describe("formatRelativeTime", () => {
+  const now = 2000000; // fixed "now" reference for deterministic tests
+
+  it('returns "—" for timestamp 0', () => {
+    expect(formatRelativeTime(0, now)).toBe("—");
+  });
+
+  it('returns "just now" for future timestamps', () => {
+    expect(formatRelativeTime(now + 5000, now)).toBe("just now");
+  });
+
+  it('returns "< 1m ago" for less than 60 seconds', () => {
+    expect(formatRelativeTime(now - 1000, now)).toBe("< 1m ago");
+    expect(formatRelativeTime(now - 59000, now)).toBe("< 1m ago");
+  });
+
+  it("returns minutes ago for 1-59 minutes", () => {
+    expect(formatRelativeTime(now - 60000, now)).toBe("1m ago");
+    expect(formatRelativeTime(now - 120000, now)).toBe("2m ago");
+    expect(formatRelativeTime(now - 3540000, now)).toBe("59m ago");
+  });
+
+  it("returns hours ago for 1-23 hours", () => {
+    expect(formatRelativeTime(now - 3600000, now)).toBe("1h ago");
+    expect(formatRelativeTime(now - 7200000, now)).toBe("2h ago");
+    expect(formatRelativeTime(now - 82800000, now)).toBe("23h ago");
+  });
+
+  it("returns days ago for 1-29 days", () => {
+    expect(formatRelativeTime(now - 86400000, now)).toBe("1d ago");
+    expect(formatRelativeTime(now - 86400000 * 7, now)).toBe("7d ago");
+    expect(formatRelativeTime(now - 86400000 * 29, now)).toBe("29d ago");
+  });
+
+  it('returns "> 30d ago" for 30+ days', () => {
+    expect(formatRelativeTime(now - 86400000 * 30, now)).toBe("> 30d ago");
+    expect(formatRelativeTime(now - 86400000 * 100, now)).toBe("> 30d ago");
+  });
+
+  it("uses Date.now() when nowMs is not provided", () => {
+    const result = formatRelativeTime(Date.now() - 60000);
+    expect(result).toMatch(/^(< 1m|\d+m) ago$/);
+  });
+
+  it("handles exactly 60 seconds boundary", () => {
+    expect(formatRelativeTime(now - 60000, now)).toBe("1m ago");
+  });
+
+  it("handles exactly 60 minutes boundary", () => {
+    expect(formatRelativeTime(now - 3600000, now)).toBe("1h ago");
+  });
+
+  it("handles exactly 24 hours boundary", () => {
+    expect(formatRelativeTime(now - 86400000, now)).toBe("1d ago");
+  });
+
+  it("handles exactly 30 days boundary", () => {
+    expect(formatRelativeTime(now - 86400000 * 30, now)).toBe("> 30d ago");
+  });
+
+  it("handles negative timestamp (future) gracefully", () => {
+    expect(formatRelativeTime(now + 1, now)).toBe("just now");
+  });
+});
+
+// ─── formatDuration (format-time: ms → compact downtime string) ──────────────
+
+describe("formatDuration (ms)", () => {
+  it("formats seconds when under 1 minute", () => {
+    expect(formatDuration(0)).toBe("0s");
+    expect(formatDuration(1000)).toBe("1s");
+    expect(formatDuration(30000)).toBe("30s");
+    expect(formatDuration(59000)).toBe("59s");
+  });
+
+  it("formats minutes with seconds when seconds remain", () => {
+    expect(formatDuration(60000)).toBe("1m");
+    expect(formatDuration(61000)).toBe("1m 1s");
+    expect(formatDuration(90000)).toBe("1m 30s");
+    expect(formatDuration(3540000)).toBe("59m");
+  });
+
+  it("formats hours when 1+ hour", () => {
+    expect(formatDuration(3600000)).toBe("1h");
+    expect(formatDuration(3661000)).toBe("1h 1m");
+    expect(formatDuration(7200000)).toBe("2h");
+    expect(formatDuration(7260000)).toBe("2h 1m");
+  });
+
+  it("handles large durations", () => {
+    expect(formatDuration(90000000)).toBe("25h");
+    expect(formatDuration(91800000)).toBe("25h 30m");
+  });
+
+  it("handles milliseconds below 1 second", () => {
+    expect(formatDuration(500)).toBe("0s");
+    expect(formatDuration(999)).toBe("0s");
+  });
+});
+
+// ─── Shared number / uptime / latency formatters ─────────────────────────────
+
+describe("formatNumber (shared)", () => {
+  it("formats thousands with K suffix", () => {
+    expect(formatNumber(1500)).toBe("1.5K");
+    expect(formatNumber(2000)).toBe("2.0K");
+    expect(formatNumber(999000)).toBe("999.0K");
+  });
+
+  it("formats millions with M suffix", () => {
+    expect(formatNumber(1500000)).toBe("1.5M");
+    expect(formatNumber(2000000)).toBe("2.0M");
+  });
+
+  it("returns locale string for numbers under 1000", () => {
+    expect(formatNumber(500)).toBe((500).toLocaleString());
+    expect(formatNumber(0)).toBe((0).toLocaleString());
+    expect(formatNumber(999)).toBe((999).toLocaleString());
+  });
+
+  it("handles non-finite", () => {
+    expect(formatNumber(NaN)).toBe("—");
+    expect(formatNumber(Infinity)).toBe("—");
+  });
+});
+
+describe("formatUptime / formatDurationCompact (seconds)", () => {
+  it("formats seconds", () => {
+    expect(formatDurationCompact(0)).toBe("0s");
+    expect(formatDurationCompact(30)).toBe("30s");
+    expect(formatDurationCompact(59)).toBe("59s");
+  });
+
+  it("formats minutes", () => {
+    expect(formatDurationCompact(60)).toBe("1m");
+    expect(formatDurationCompact(90)).toBe("1m");
+    expect(formatDurationCompact(3599)).toBe("59m");
+  });
+
+  it("formats hours with minutes", () => {
+    expect(formatDurationCompact(3600)).toBe("1h 0m");
+    expect(formatDurationCompact(3661)).toBe("1h 1m");
+    expect(formatDurationCompact(7200)).toBe("2h 0m");
+  });
+
+  it("formats days with hours", () => {
+    expect(formatDurationCompact(86400)).toBe("1d 0h");
+    expect(formatDurationCompact(90000)).toBe("1d 1h");
+    expect(formatDurationCompact(172800)).toBe("2d 0h");
+  });
+
+  it("formatUptime delegates to full formatDuration (seconds)", () => {
+    // formatUptime uses multi-part formatDuration (d/h/m/s)
+    expect(formatUptime(125)).toBe("2m 5s");
+    expect(formatUptime(3661)).toBe("1h 1m 1s");
+  });
+});
+
+describe("formatLatency", () => {
+  it("formats sub-millisecond latency", () => {
+    expect(formatLatency(0)).toBe("<1ms");
+    expect(formatLatency(0.5)).toBe("<1ms");
+  });
+
+  it("formats millisecond latency", () => {
+    expect(formatLatency(1)).toBe("1ms");
+    expect(formatLatency(45)).toBe("45ms");
+    expect(formatLatency(500)).toBe("500ms");
+    expect(formatLatency(999)).toBe("999ms");
+  });
+
+  it("formats second-level latency", () => {
+    expect(formatLatency(1000)).toBe("1.0s");
+    expect(formatLatency(2500)).toBe("2.5s");
+    expect(formatLatency(15000)).toBe("15.0s");
+  });
+
+  it("handles non-finite", () => {
+    expect(formatLatency(NaN)).toBe("—");
+  });
+});
+
+describe("formatPercent", () => {
+  it("formats percentages with sign prefix", () => {
+    expect(formatPercent(50, 1)).toBe("+50.0%");
+    expect(formatPercent(99.9, 1)).toBe("+99.9%");
+    expect(formatPercent(0, 1)).toBe("+0.0%");
+    expect(formatPercent(-12.5, 1)).toBe("-12.5%");
+  });
+
+  it("handles non-finite", () => {
+    expect(formatPercent(NaN)).toBe("—");
+  });
+});
+
+describe("formatRequests", () => {
+  it("formats via formatNumber", () => {
+    expect(formatRequests(0)).toBe((0).toLocaleString());
+    expect(formatRequests(42)).toBe((42).toLocaleString());
+    expect(formatRequests(999)).toBe((999).toLocaleString());
+    expect(formatRequests(1000)).toBe("1.0K");
+    expect(formatRequests(1500)).toBe("1.5K");
+    expect(formatRequests(1000000)).toBe("1.0M");
+  });
+});

package/src/view-registry.test.ts

@@ -0,0 +1,132 @@
+/**
+ * Copyright (c) 2026 HOOX · HOOX · jango-blockchained (hoox-sh)
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { describe, it, expect } from "bun:test";
+import type { ViewId } from "@hoox-sh/hoox-shared";
+import {
+  VIEW_REGISTRY,
+  REGISTERED_VIEW_IDS,
+  SIDEBAR_ITEMS,
+  getSidebarItems,
+  getViewShortcutMap,
+  getCtrlAltViewMap,
+  getViewPaletteCommands,
+  getViewFactory,
+  isRegisteredViewId,
+  ACTION_COMMANDS,
+  ALL_PALETTE_COMMANDS,
+} from "./view-registry";
+
+const ALL_VIEWS: ViewId[] = [
+  "dashboard",
+  "workers",
+  "worker-detail",
+  "trade-monitor",
+  "logs-viewer",
+  "service-manager",
+  "config-editor",
+  "setup-wizard",
+  "settings",
+  "queue-depth",
+  "kv-viewer",
+  "secrets-viewer",
+  "db-query",
+  "ai-chat",
+  "edge-topology",
+  "worker-settings",
+];
+
+describe("view-registry", () => {
+  it("covers every ViewId exactly once in order", () => {
+    expect(VIEW_REGISTRY.map((v) => v.id)).toEqual(ALL_VIEWS);
+    expect(REGISTERED_VIEW_IDS).toEqual(ALL_VIEWS);
+  });
+
+  it("sidebar items match registry short labels", () => {
+    const items = getSidebarItems();
+    expect(items).toHaveLength(ALL_VIEWS.length);
+    expect(items).toEqual(SIDEBAR_ITEMS);
+    expect(items[0]).toEqual({
+      id: "dashboard",
+      label: "DASHBOARD",
+      shortcut: "1",
+    });
+  });
+
+  it("Ctrl digit shortcuts map 1-9 and 0", () => {
+    const map = getViewShortcutMap();
+    expect(map["1"]).toBe("dashboard");
+    expect(map["0"]).toBe("queue-depth");
+    expect(map["9"]).toBe("settings");
+    expect(Object.keys(map)).toHaveLength(10);
+  });
+
+  it("Ctrl+Alt chords map k/s/c/q/e/w", () => {
+    const map = getCtrlAltViewMap();
+    expect(map.k).toBe("kv-viewer");
+    expect(map.s).toBe("secrets-viewer");
+    expect(map.c).toBe("ai-chat");
+    expect(map.q).toBe("db-query");
+    expect(map.e).toBe("edge-topology");
+    expect(map.w).toBe("worker-settings");
+    expect(Object.keys(map)).toHaveLength(6);
+  });
+
+  it("ctrl and ctrl-alt key sets are unique", () => {
+    const ctrl = VIEW_REGISTRY.filter((e) => e.keyMod === "ctrl").map(
+      (e) => e.key
+    );
+    const ctrlAlt = VIEW_REGISTRY.filter((e) => e.keyMod === "ctrl-alt").map(
+      (e) => e.key
+    );
+    expect(new Set(ctrl).size).toBe(ctrl.length);
+    expect(new Set(ctrlAlt).size).toBe(ctrlAlt.length);
+  });
+
+  it("palette view commands include all views", () => {
+    const cmds = getViewPaletteCommands();
+    expect(cmds.every((c) => c.category === "view")).toBe(true);
+    expect(new Set(cmds.map((c) => c.id))).toEqual(new Set(ALL_VIEWS));
+  });
+
+  it("every view has a factory", () => {
+    for (const id of ALL_VIEWS) {
+      expect(typeof getViewFactory(id)).toBe("function");
+    }
+  });
+
+  it("isRegisteredViewId accepts all registry ids and rejects junk", () => {
+    for (const id of ALL_VIEWS) {
+      expect(isRegisteredViewId(id)).toBe(true);
+    }
+    expect(isRegisteredViewId("not-a-view")).toBe(false);
+    expect(isRegisteredViewId(null)).toBe(false);
+    expect(isRegisteredViewId(42)).toBe(false);
+    expect(isRegisteredViewId("")).toBe(false);
+  });
+
+  it("action commands include refresh, toggle-sidebar, quit", () => {
+    const ids = ACTION_COMMANDS.map((c) => c.id);
+    expect(ids).toContain("refresh");
+    expect(ids).toContain("toggle-sidebar");
+    expect(ids).toContain("quit");
+  });
+
+  it("ALL_PALETTE_COMMANDS merges views + actions without id collisions", () => {
+    expect(ALL_PALETTE_COMMANDS.length).toBe(
+      getViewPaletteCommands().length + ACTION_COMMANDS.length
+    );
+    const ids = ALL_PALETTE_COMMANDS.map((c) => c.id);
+    expect(new Set(ids).size).toBe(ids.length);
+  });
+
+  it("action shortcuts do not collide with view Ctrl digits", () => {
+    // refresh=R, sidebar=B, quit=Q — none are digit view keys
+    const digitKeys = new Set(Object.keys(getViewShortcutMap()));
+    expect(digitKeys.has("r")).toBe(false);
+    expect(digitKeys.has("b")).toBe(false);
+    expect(digitKeys.has("q")).toBe(false);
+  });
+});