@hoox-sh/hoox-tui 0.2.0

package/src/components/views/worker-detail.test.tsx

@@ -0,0 +1,289 @@
+/**
+ * Copyright (c) 2026 HOOX · HOOX · jango-blockchained (hoox-sh)
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+/**
+ * WorkerDetail view tests.
+ *
+ * Covers:
+ *   - Worker name and status in header
+ *   - 4 panes render with correct store data
+ *   - Tab cycles focus between panes
+ *   - Esc triggers goBack
+ *   - Missing worker shows error state
+ *
+ * Uses Bun test runner. Tests are structural — verifying that
+ * the component produces the expected render tree given store state.
+ * Not a full TUI render test (which requires a terminal).
+ */
+import { describe, test, expect, beforeEach } from "bun:test";
+
+import { useServiceStore } from "@hoox-sh/hoox-shared/stores/service-store";
+import { useUIStore } from "@hoox-sh/hoox-shared/stores/ui-store";
+import {
+  makeWorker,
+  makeLog,
+  type TestLogEntry,
+  type ConnectionStatus,
+} from "../../test-utils";
+import { redactConfigEntries } from "./worker-detail";
+
+/** Reset stores to initial state before each test */
+function resetStores() {
+  useServiceStore.setState({
+    workers: [],
+    logs: [],
+    metrics: null,
+    connectionStatus: "offline" as ConnectionStatus,
+    selectedWorkerId: null,
+    lastUpdated: 0,
+    alerts: [],
+    tradeStream: [],
+  });
+  useUIStore.setState({
+    activeView: "worker-detail",
+    previousView: "workers",
+    sidebarExpanded: true,
+    modal: null,
+    commandPaletteOpen: false,
+  });
+}
+
+// ── Tests ────────────────────────────────────────────────────────────────────
+
+describe("WorkerDetail", () => {
+  beforeEach(() => {
+    resetStores();
+  });
+
+  test("renders worker name and status in header", () => {
+    const worker = makeWorker({
+      name: "trade-executor",
+      status: "operational",
+    });
+
+    useServiceStore.setState({
+      workers: [worker],
+      selectedWorkerId: worker.id,
+    });
+
+    // The WorkerDetail component shows breadcrumb:
+    // "← BACK | trade-executor | █ OPERATIONAL"
+    // We verify the store is set correctly (structural test).
+    const selectedId = useServiceStore.getState().selectedWorkerId;
+    const found = useServiceStore
+      .getState()
+      .workers.find((w) => w.id === selectedId);
+
+    expect(selectedId).toBe("test-worker-1");
+    expect(found).toBeDefined();
+    expect(found!.name).toBe("trade-executor");
+    expect(found!.status).toBe("operational");
+  });
+
+  test("4 panes render with correct data from store", () => {
+    const worker = makeWorker({
+      cpu: 42.5,
+      memory: 64,
+      requests: 15000,
+      durableObjectCount: 3,
+      uptime: 86400,
+      edgeCount: 12,
+    });
+
+    useServiceStore.setState({
+      workers: [worker],
+      selectedWorkerId: worker.id,
+    });
+
+    const state = useServiceStore.getState();
+    const found = state.workers.find((w) => w.id === state.selectedWorkerId);
+
+    // Metrics pane data
+    expect(found!.cpu).toBe(42.5);
+    expect(found!.memory).toBe(64);
+    expect(found!.requests).toBe(15000);
+    expect(found!.uptime).toBe(86400);
+
+    // Durable Objects pane
+    expect(found!.durableObjectCount).toBe(3);
+
+    // Config Preview data
+    expect(found!.version).toBe("1.2.3");
+    expect(found!.edgeCount).toBe(12);
+  });
+
+  test("tab cycles focus between panes", () => {
+    // Focus starts at 0 (Metrics)
+    // After 4 tabs, it should wrap back to 0
+    let focus = 0;
+    const PANE_COUNT = 4;
+
+    focus = (focus + 1) % PANE_COUNT; // → 1 (Live Logs)
+    expect(focus).toBe(1);
+
+    focus = (focus + 1) % PANE_COUNT; // → 2 (Durable Objects)
+    expect(focus).toBe(2);
+
+    focus = (focus + 1) % PANE_COUNT; // → 3 (Config Preview)
+    expect(focus).toBe(3);
+
+    focus = (focus + 1) % PANE_COUNT; // → 0 (Metrics)
+    expect(focus).toBe(0);
+  });
+
+  test("esc triggers goBack via UI store", () => {
+    // Set up: user navigated from "workers" to "worker-detail"
+    useUIStore.setState({
+      activeView: "worker-detail",
+      previousView: "workers",
+    });
+
+    // Simulate Esc → goBack()
+    useUIStore.getState().goBack();
+
+    const state = useUIStore.getState();
+    expect(state.activeView).toBe("workers");
+    expect(state.previousView).toBeNull();
+  });
+
+  test("error boundary handles missing worker", () => {
+    // No worker selected
+    useServiceStore.setState({
+      workers: [],
+      selectedWorkerId: "non-existent",
+    });
+
+    const state = useServiceStore.getState();
+    const found = state.workers.find((w) => w.id === state.selectedWorkerId);
+
+    expect(found).toBeUndefined();
+    expect(state.selectedWorkerId).toBe("non-existent");
+    // The component should render its fallback "Worker Not Found" UI
+  });
+
+  test("logs pane shows filtered worker logs", () => {
+    const worker = makeWorker({ id: "w1", name: "trade-executor" });
+    const logs: TestLogEntry[] = [
+      makeLog({ id: "l1", workerId: "w1", level: "info", message: "Started" }),
+      makeLog({
+        id: "l2",
+        workerId: "w1",
+        level: "warn",
+        message: "High latency",
+      }),
+      makeLog({
+        id: "l3",
+        workerId: "w2",
+        level: "error",
+        message: "Other worker",
+      }),
+    ];
+
+    useServiceStore.setState({
+      workers: [worker],
+      selectedWorkerId: "w1",
+      logs,
+    });
+
+    const state = useServiceStore.getState();
+
+    // Only logs for worker "w1" should be relevant
+    const workerLogs = state.logs.filter((l) => l.workerId === "w1");
+    expect(workerLogs).toHaveLength(2);
+    expect(workerLogs[0].level).toBe("info");
+    expect(workerLogs[1].level).toBe("warn");
+
+    // The log for worker "w2" should be filtered out
+    const otherLogs = state.logs.filter((l) => l.workerId === "w2");
+    expect(otherLogs).toHaveLength(1);
+  });
+
+  test("metrics pane reflects degraded worker correctly", () => {
+    const degraded = makeWorker({
+      id: "w-degraded",
+      name: "rate-limiter",
+      status: "degraded",
+      cpu: 85,
+      memory: 110,
+      requests: 500,
+    });
+
+    useServiceStore.setState({
+      workers: [degraded],
+      selectedWorkerId: "w-degraded",
+    });
+
+    const state = useServiceStore.getState();
+    const found = state.workers.find((w) => w.id === state.selectedWorkerId);
+
+    expect(found).toBeDefined();
+    expect(found!.status).toBe("degraded");
+    expect(found!.cpu).toBeGreaterThan(80); // should trigger warning/error colors
+    expect(found!.memory).toBeGreaterThan(100);
+  });
+
+  test("formatUptime produces human-readable duration", () => {
+    // Test the helper logic (imported inline for isolation)
+    function formatUptime(seconds: number): string {
+      if (seconds < 60) return `${seconds}s`;
+      if (seconds < 3600) return `${Math.floor(seconds / 60)}m`;
+      if (seconds < 86400)
+        return `${Math.floor(seconds / 3600)}h ${Math.floor((seconds % 3600) / 60)}m`;
+      const days = Math.floor(seconds / 86400);
+      const hours = Math.floor((seconds % 86400) / 3600);
+      return `${days}d ${hours}h`;
+    }
+
+    expect(formatUptime(30)).toBe("30s");
+    expect(formatUptime(90)).toBe("1m");
+    expect(formatUptime(3661)).toBe("1h 1m");
+    expect(formatUptime(90000)).toBe("1d 1h");
+    expect(formatUptime(172800)).toBe("2d 0h");
+  });
+
+  test("log level colors match expected tokens", async () => {
+    const { LogLevelColor, Colors } = await import("@hoox-sh/hoox-shared");
+    expect(LogLevelColor.debug).toBe(Colors.muted);
+    expect(LogLevelColor.info).toBe(Colors.foreground);
+    expect(LogLevelColor.warn).toBe(Colors.warning);
+    expect(LogLevelColor.error).toBe(Colors.error);
+  });
+
+  test("redactConfigEntries never surfaces secret-looking keys cleartext", () => {
+    const entries = redactConfigEntries({
+      name: "trade-executor",
+      status: "operational",
+      apiKey: "sk-live-super-secret-value",
+      HOOX_API_TOKEN: "token-abc-12345678",
+      nested: { client_secret: "shh", mode: "prod" },
+      note: "Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.payload",
+    });
+
+    const byKey = Object.fromEntries(entries.map((e) => [e.key, e.value]));
+    expect(byKey.name).toBe("trade-executor");
+    expect(byKey.status).toBe("operational");
+    expect(byKey.apiKey).toBe("[redacted]");
+    expect(byKey.HOOX_API_TOKEN).toBe("[redacted]");
+    // Nested secret keys redacted by redactDevLogContext
+    expect(byKey.nested).not.toContain("shh");
+    expect(byKey.note).toContain("[redacted]");
+    expect(byKey.note).not.toContain("eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9");
+  });
+
+  test("redactConfigEntries preserves non-secret identity fields", () => {
+    const entries = redactConfigEntries({
+      version: "1.2.3",
+      edgeCount: 12,
+      strategy: "grid",
+    });
+    expect(entries).toEqual(
+      expect.arrayContaining([
+        { key: "version", value: "1.2.3" },
+        { key: "edgeCount", value: "12" },
+        { key: "strategy", value: "grid" },
+      ])
+    );
+  });
+});