gitforest 0.1.0

package/test/unit/hooks/useKeyBindings.isolated.ts

@@ -0,0 +1,715 @@
+/**
+ * Tests for useKeyBindings hook
+ * 
+ * Note: Testing React hooks that depend on external modules (ink, Bun) requires
+ * careful mocking. These tests focus on verifying the key binding logic
+ * by testing the dispatch calls that would be made.
+ */
+
+import { describe, test, expect, beforeAll, beforeEach, afterAll, mock } from "bun:test";
+
+// Mock the dependencies at module level
+const mockExit = mock(() => {});
+const mockDispatch = mock((action: any) => {});
+const mockOnRefresh = mock(async () => {});
+const mockBun$ = mock(() => ({ quiet: () => {} }));
+
+// Default state factory
+function createDefaultState() {
+  return {
+    projects: [],
+    isLoading: false,
+    error: null,
+    message: null,
+    cursorIndex: 0,
+    selectedIndices: new Set(),
+    scrollOffset: 0,
+    filterText: "",
+    quickFilter: "all",
+    sortBy: "status",
+    sortDirection: "desc",
+    mode: "normal",
+    actionInProgress: null,
+    actionProgress: null,
+    confirmDialog: null,
+    viewMode: "combined",
+    detailModal: null,
+    cloneDialog: null,
+    refreshing: false,
+    unifiedRepos: [],
+    githubRepos: [],
+    isLoadingGitHub: false,
+    githubError: null,
+    isRefreshing: false,
+    languageFilter: null,
+  };
+}
+
+// Helper to simulate key input
+function simulateKeyInput(input: string, key: any = {}) {
+  const handler = (globalThis as any).__testInputHandler;
+  if (!handler) {
+    throw new Error("useInput handler not found. Make sure to initialize useKeyBindings first.");
+  }
+  handler(input, key);
+}
+
+// Helper to set test state
+function setTestState(state: any) {
+  (globalThis as any).__testState = { ...createDefaultState(), ...state };
+}
+
+// Mock config
+const mockConfig = {
+  directories: [{ path: "/test", maxDepth: 2 }],
+  scan: { 
+    ignore: ["node_modules", ".git"],
+    includeHidden: false,
+    concurrency: 5 
+  },
+  github: { defaultVisibility: "private" as const },
+  display: {
+    showSubmodules: true,
+    showNonGitProjects: true,
+    sortBy: "status" as const,
+    sortDirection: "desc" as const,
+  },
+  cache: {
+    ttlSeconds: 300,
+    githubTtlSeconds: 600,
+    enableBackgroundRefresh: true,
+    backgroundRefreshIntervalSeconds: 300,
+  },
+  commands: [
+    { key: "t", name: "test", command: "npm test", confirm: false, background: false },
+    { key: "b", name: "build", command: "npm run build", confirm: false, background: false },
+  ],
+};
+
+describe("useKeyBindings", () => {
+  beforeAll(() => {
+    // Set up module mocks before all tests
+    mock.module("ink", () => ({
+      useInput: (handler: (input: string, key: any) => void) => {
+        // Store the handler globally for testing
+        (globalThis as any).__testInputHandler = handler;
+      },
+      useApp: () => ({ exit: mockExit }),
+    }));
+
+    mock.module("../../../src/state/store.tsx", () => ({
+      useStore: () => ({
+        state: (globalThis as any).__testState || createDefaultState(),
+        dispatch: mockDispatch,
+      }),
+      useFilteredProjects: () => [],
+      useSelectedProjects: () => [],
+      useFilteredUnifiedRepos: () => (globalThis as any).__testState?.unifiedRepos || [],
+      useSelectedUnifiedRepos: () => [],
+    }));
+
+    mock.module("../../../src/operations/batch.ts", () => ({
+      batchPull: mock(() => Promise.resolve({ total: 0, successful: 0, failed: 0, results: [], duration: 0 })),
+      batchPush: mock(() => Promise.resolve({ total: 0, successful: 0, failed: 0, results: [], duration: 0 })),
+      batchFetch: mock(() => Promise.resolve({ total: 0, successful: 0, failed: 0, results: [], duration: 0 })),
+    }));
+
+    mock.module("../../../src/git/operations.ts", () => ({
+      initGitInProject: mock(() => Promise.resolve({ success: true })),
+    }));
+
+    mock.module("../../../src/operations/commands.ts", () => ({
+      executeCommand: mock(() => Promise.resolve({ success: true, output: "" })),
+      findCommandByKey: mock(() => null),
+    }));
+
+    mock.module("../../../src/utils/errors.ts", () => ({
+      errorToString: mock((error: any) => String(error)),
+    }));
+
+    // Mock Bun
+    mock.module("bun", () => ({
+      $: mockBun$,
+      file: mock((path: string) => ({
+        exists: mock(() => Promise.resolve(false)),
+        text: mock(() => Promise.resolve("")),
+      })),
+    }));
+  });
+
+  beforeEach(() => {
+    // Clear all mocks
+    mockDispatch.mockClear();
+    mockExit.mockClear();
+    mockOnRefresh.mockClear();
+    mockBun$.mockClear();
+    
+    // Reset test state
+    setTestState({});
+    (globalThis as any).__testInputHandler = null;
+  });
+
+  afterAll(() => {
+    // Restore mocks after all tests complete
+    mock.restore();
+  });
+
+  describe("Navigation tests", () => {
+    test("j moves cursor down", async () => {
+      const { useKeyBindings } = await import("../../../src/hooks/useKeyBindings.ts");
+      useKeyBindings({ config: mockConfig, onRefresh: mockOnRefresh });
+      
+      simulateKeyInput("j");
+      
+      expect(mockDispatch).toHaveBeenCalledWith({
+        type: "MOVE_CURSOR",
+        payload: 1,
+      });
+    });
+
+    test("down arrow moves cursor down", async () => {
+      const { useKeyBindings } = await import("../../../src/hooks/useKeyBindings.ts");
+      useKeyBindings({ config: mockConfig, onRefresh: mockOnRefresh });
+      
+      simulateKeyInput("", { downArrow: true });
+      
+      expect(mockDispatch).toHaveBeenCalledWith({
+        type: "MOVE_CURSOR",
+        payload: 1,
+      });
+    });
+
+    test("k moves cursor up", async () => {
+      setTestState({ cursorIndex: 5 });
+      
+      const { useKeyBindings } = await import("../../../src/hooks/useKeyBindings.ts");
+      useKeyBindings({ config: mockConfig, onRefresh: mockOnRefresh });
+      
+      simulateKeyInput("k");
+      
+      expect(mockDispatch).toHaveBeenCalledWith({
+        type: "MOVE_CURSOR",
+        payload: 4,
+      });
+    });
+
+    test("up arrow moves cursor up", async () => {
+      setTestState({ cursorIndex: 3 });
+      
+      const { useKeyBindings } = await import("../../../src/hooks/useKeyBindings.ts");
+      useKeyBindings({ config: mockConfig, onRefresh: mockOnRefresh });
+      
+      simulateKeyInput("", { upArrow: true });
+      
+      expect(mockDispatch).toHaveBeenCalledWith({
+        type: "MOVE_CURSOR",
+        payload: 2,
+      });
+    });
+
+    test("g moves to first item", async () => {
+      setTestState({ cursorIndex: 10 });
+      
+      const { useKeyBindings } = await import("../../../src/hooks/useKeyBindings.ts");
+      useKeyBindings({ config: mockConfig, onRefresh: mockOnRefresh });
+      
+      simulateKeyInput("g");
+      
+      expect(mockDispatch).toHaveBeenCalledWith({
+        type: "MOVE_CURSOR",
+        payload: 0,
+      });
+    });
+
+    test("G moves to last item", async () => {
+      setTestState({ 
+        cursorIndex: 0,
+        viewMode: "combined",
+        unifiedRepos: [1, 2, 3], // Mock 3 items
+      });
+      
+      const { useKeyBindings } = await import("../../../src/hooks/useKeyBindings.ts");
+      useKeyBindings({ config: mockConfig, onRefresh: mockOnRefresh });
+      
+      simulateKeyInput("G");
+      
+      // Should move to last item (2)
+      expect(mockDispatch).toHaveBeenCalledWith({
+        type: "MOVE_CURSOR",
+        payload: 2,
+      });
+    });
+  });
+
+  describe("Selection tests", () => {
+    test("space toggles selection", async () => {
+      setTestState({ cursorIndex: 2 });
+      
+      const { useKeyBindings } = await import("../../../src/hooks/useKeyBindings.ts");
+      useKeyBindings({ config: mockConfig, onRefresh: mockOnRefresh });
+      
+      simulateKeyInput(" ");
+      
+      expect(mockDispatch).toHaveBeenCalledWith({
+        type: "TOGGLE_SELECTION",
+        payload: 2,
+      });
+    });
+
+    test("a selects all when none selected", async () => {
+      setTestState({ 
+        selectedIndices: new Set(),
+        viewMode: "combined",
+        unifiedRepos: [1, 2], // Mock 2 items
+      });
+      
+      const { useKeyBindings } = await import("../../../src/hooks/useKeyBindings.ts");
+      useKeyBindings({ config: mockConfig, onRefresh: mockOnRefresh });
+      
+      simulateKeyInput("a");
+      
+      expect(mockDispatch).toHaveBeenCalledWith({
+        type: "SELECT_ALL",
+      });
+    });
+
+    test("a deselects all when all selected", async () => {
+      setTestState({ 
+        selectedIndices: new Set([0, 1]),
+        viewMode: "combined",
+        unifiedRepos: [1, 2], // Mock 2 items
+      });
+      
+      const { useKeyBindings } = await import("../../../src/hooks/useKeyBindings.ts");
+      useKeyBindings({ config: mockConfig, onRefresh: mockOnRefresh });
+      
+      simulateKeyInput("a");
+      
+      expect(mockDispatch).toHaveBeenCalledWith({
+        type: "DESELECT_ALL",
+      });
+    });
+  });
+
+  describe("Filter tests", () => {
+    test("/ enters filter mode", async () => {
+      const { useKeyBindings } = await import("../../../src/hooks/useKeyBindings.ts");
+      useKeyBindings({ config: mockConfig, onRefresh: mockOnRefresh });
+      
+      simulateKeyInput("/");
+      
+      expect(mockDispatch).toHaveBeenCalledWith({
+        type: "SET_MODE",
+        payload: "filter",
+      });
+    });
+
+    test("escape exits filter mode", async () => {
+      setTestState({ mode: "filter" });
+      
+      const { useKeyBindings } = await import("../../../src/hooks/useKeyBindings.ts");
+      useKeyBindings({ config: mockConfig, onRefresh: mockOnRefresh });
+      
+      simulateKeyInput("", { escape: true });
+      
+      expect(mockDispatch).toHaveBeenCalledWith({
+        type: "SET_MODE",
+        payload: "normal",
+      });
+      expect(mockDispatch).toHaveBeenCalledWith({
+        type: "SET_FILTER",
+        payload: "",
+      });
+    });
+
+    test("return exits filter mode", async () => {
+      setTestState({ mode: "filter" });
+      
+      const { useKeyBindings } = await import("../../../src/hooks/useKeyBindings.ts");
+      useKeyBindings({ config: mockConfig, onRefresh: mockOnRefresh });
+      
+      simulateKeyInput("", { return: true });
+      
+      expect(mockDispatch).toHaveBeenCalledWith({
+        type: "SET_MODE",
+        payload: "normal",
+      });
+    });
+  });
+
+  describe("Quick filter tests", () => {
+    const quickFilterTests = [
+      { key: "0", filter: "all", name: "All projects" },
+      { key: "1", filter: "dirty", name: "Dirty projects" },
+      { key: "2", filter: "unpushed", name: "Unpushed commits" },
+      { key: "3", filter: "no-remote", name: "No remote" },
+      { key: "4", filter: "github-only", name: "GitHub only" },
+      { key: "5", filter: "local-only", name: "Local only" },
+      { key: "6", filter: "private", name: "Private repos" },
+      { key: "7", filter: "public", name: "Public repos" },
+      { key: "8", filter: "archived", name: "Archived repos" },
+      { key: "9", filter: "forks", name: "Forked repos" },
+    ];
+
+    for (const { key, filter, name } of quickFilterTests) {
+      test(`${key} applies ${filter} quick filter`, async () => {
+        const { useKeyBindings } = await import("../../../src/hooks/useKeyBindings.ts");
+        useKeyBindings({ config: mockConfig, onRefresh: mockOnRefresh });
+        
+        simulateKeyInput(key);
+        
+        expect(mockDispatch).toHaveBeenCalledWith({
+          type: "SET_QUICK_FILTER",
+          payload: filter,
+        });
+        expect(mockDispatch).toHaveBeenCalledWith({
+          type: "SET_MESSAGE",
+          payload: `Filter: ${name}`,
+        });
+      });
+    }
+  });
+
+  describe("Sort tests", () => {
+    test("s cycles sort field", async () => {
+      const { useKeyBindings } = await import("../../../src/hooks/useKeyBindings.ts");
+      useKeyBindings({ config: mockConfig, onRefresh: mockOnRefresh });
+      
+      simulateKeyInput("s");
+      
+      expect(mockDispatch).toHaveBeenCalledWith({
+        type: "CYCLE_SORT",
+      });
+    });
+
+    test("S reverses sort direction", async () => {
+      setTestState({ 
+        sortBy: "name",
+        sortDirection: "desc" 
+      });
+      
+      const { useKeyBindings } = await import("../../../src/hooks/useKeyBindings.ts");
+      useKeyBindings({ config: mockConfig, onRefresh: mockOnRefresh });
+      
+      simulateKeyInput("S");
+      
+      expect(mockDispatch).toHaveBeenCalledWith({
+        type: "SET_SORT",
+        payload: { by: "name", direction: "asc" },
+      });
+      expect(mockDispatch).toHaveBeenCalledWith({
+        type: "SET_MESSAGE",
+        payload: "Sort: name ↑",
+      });
+    });
+
+    test("S changes from asc to desc", async () => {
+      setTestState({ 
+        sortBy: "name",
+        sortDirection: "asc" 
+      });
+      
+      const { useKeyBindings } = await import("../../../src/hooks/useKeyBindings.ts");
+      useKeyBindings({ config: mockConfig, onRefresh: mockOnRefresh });
+      
+      simulateKeyInput("S");
+      
+      expect(mockDispatch).toHaveBeenCalledWith({
+        type: "SET_SORT",
+        payload: { by: "name", direction: "desc" },
+      });
+      expect(mockDispatch).toHaveBeenCalledWith({
+        type: "SET_MESSAGE",
+        payload: "Sort: name ↓",
+      });
+    });
+  });
+
+  describe("View mode tests", () => {
+    test("tab cycles view modes", async () => {
+      setTestState({ viewMode: "local" });
+      
+      const { useKeyBindings } = await import("../../../src/hooks/useKeyBindings.ts");
+      useKeyBindings({ config: mockConfig, onRefresh: mockOnRefresh });
+      
+      simulateKeyInput("", { tab: true });
+      
+      expect(mockDispatch).toHaveBeenCalledWith({
+        type: "SET_VIEW_MODE",
+        payload: "github",
+      });
+      expect(mockDispatch).toHaveBeenCalledWith({
+        type: "SET_MESSAGE",
+        payload: "View: GitHub only",
+      });
+    });
+
+    test("tab cycles from github to combined", async () => {
+      setTestState({ viewMode: "github" });
+      
+      const { useKeyBindings } = await import("../../../src/hooks/useKeyBindings.ts");
+      useKeyBindings({ config: mockConfig, onRefresh: mockOnRefresh });
+      
+      simulateKeyInput("", { tab: true });
+      
+      expect(mockDispatch).toHaveBeenCalledWith({
+        type: "SET_VIEW_MODE",
+        payload: "combined",
+      });
+      expect(mockDispatch).toHaveBeenCalledWith({
+        type: "SET_MESSAGE",
+        payload: "View: All repos",
+      });
+    });
+
+    test("tab cycles from combined to local", async () => {
+      setTestState({ viewMode: "combined" });
+      
+      const { useKeyBindings } = await import("../../../src/hooks/useKeyBindings.ts");
+      useKeyBindings({ config: mockConfig, onRefresh: mockOnRefresh });
+      
+      simulateKeyInput("", { tab: true });
+      
+      expect(mockDispatch).toHaveBeenCalledWith({
+        type: "SET_VIEW_MODE",
+        payload: "local",
+      });
+      expect(mockDispatch).toHaveBeenCalledWith({
+        type: "SET_MESSAGE",
+        payload: "View: Local only",
+      });
+    });
+  });
+
+  describe("Mode switching tests", () => {
+    test("? opens help mode", async () => {
+      const { useKeyBindings } = await import("../../../src/hooks/useKeyBindings.ts");
+      useKeyBindings({ config: mockConfig, onRefresh: mockOnRefresh });
+      
+      simulateKeyInput("?");
+      
+      expect(mockDispatch).toHaveBeenCalledWith({
+        type: "SET_MODE",
+        payload: "help",
+      });
+    });
+
+    test("F opens filter-options mode", async () => {
+      const { useKeyBindings } = await import("../../../src/hooks/useKeyBindings.ts");
+      useKeyBindings({ config: mockConfig, onRefresh: mockOnRefresh });
+      
+      simulateKeyInput("F");
+      
+      expect(mockDispatch).toHaveBeenCalledWith({
+        type: "SET_MODE",
+        payload: "filter-options",
+      });
+    });
+
+    test("x opens command-palette mode", async () => {
+      const { useKeyBindings } = await import("../../../src/hooks/useKeyBindings.ts");
+      useKeyBindings({ config: mockConfig, onRefresh: mockOnRefresh });
+      
+      simulateKeyInput("x");
+      
+      expect(mockDispatch).toHaveBeenCalledWith({
+        type: "SET_MODE",
+        payload: "command-palette",
+      });
+    });
+
+    test("x shows message when no commands configured", async () => {
+      const configWithNoCommands = { ...mockConfig, commands: [] };
+      
+      const { useKeyBindings } = await import("../../../src/hooks/useKeyBindings.ts");
+      useKeyBindings({ config: configWithNoCommands, onRefresh: mockOnRefresh });
+      
+      simulateKeyInput("x");
+      
+      expect(mockDispatch).toHaveBeenCalledWith({
+        type: "SET_MESSAGE",
+        payload: "No commands configured",
+      });
+    });
+
+    test("q exits app", async () => {
+      const { useKeyBindings } = await import("../../../src/hooks/useKeyBindings.ts");
+      useKeyBindings({ config: mockConfig, onRefresh: mockOnRefresh });
+      
+      simulateKeyInput("q");
+      
+      expect(mockExit).toHaveBeenCalled();
+    });
+
+    test("Ctrl+C exits app", async () => {
+      const { useKeyBindings } = await import("../../../src/hooks/useKeyBindings.ts");
+      useKeyBindings({ config: mockConfig, onRefresh: mockOnRefresh });
+      
+      simulateKeyInput("c", { ctrl: true });
+      
+      expect(mockExit).toHaveBeenCalled();
+    });
+  });
+
+  describe("Detail modal tests", () => {
+    test("escape closes detail modal", async () => {
+      setTestState({ mode: "detail" });
+      
+      const { useKeyBindings } = await import("../../../src/hooks/useKeyBindings.ts");
+      useKeyBindings({ config: mockConfig, onRefresh: mockOnRefresh });
+      
+      simulateKeyInput("", { escape: true });
+      
+      expect(mockDispatch).toHaveBeenCalledWith({
+        type: "HIDE_DETAIL_MODAL",
+      });
+    });
+
+    test("j scrolls README down in detail modal", async () => {
+      setTestState({ 
+        mode: "detail",
+        detailModal: { readmeScrollOffset: 5 },
+      });
+      
+      const { useKeyBindings } = await import("../../../src/hooks/useKeyBindings.ts");
+      useKeyBindings({ config: mockConfig, onRefresh: mockOnRefresh });
+      
+      simulateKeyInput("j");
+      
+      expect(mockDispatch).toHaveBeenCalledWith({
+        type: "UPDATE_DETAIL_MODAL",
+        payload: { readmeScrollOffset: 6 },
+      });
+    });
+
+    test("k scrolls README up in detail modal", async () => {
+      setTestState({ 
+        mode: "detail",
+        detailModal: { readmeScrollOffset: 5 },
+      });
+      
+      const { useKeyBindings } = await import("../../../src/hooks/useKeyBindings.ts");
+      useKeyBindings({ config: mockConfig, onRefresh: mockOnRefresh });
+      
+      simulateKeyInput("k");
+      
+      expect(mockDispatch).toHaveBeenCalledWith({
+        type: "UPDATE_DETAIL_MODAL",
+        payload: { readmeScrollOffset: 4 },
+      });
+    });
+
+    test("k prevents negative scroll offset", async () => {
+      setTestState({ 
+        mode: "detail",
+        detailModal: { readmeScrollOffset: 0 },
+      });
+      
+      const { useKeyBindings } = await import("../../../src/hooks/useKeyBindings.ts");
+      useKeyBindings({ config: mockConfig, onRefresh: mockOnRefresh });
+      
+      simulateKeyInput("k");
+      
+      expect(mockDispatch).toHaveBeenCalledWith({
+        type: "UPDATE_DETAIL_MODAL",
+        payload: { readmeScrollOffset: 0 },
+      });
+    });
+  });
+
+  describe("Help and filter options mode tests", () => {
+    test("any key closes help mode", async () => {
+      setTestState({ mode: "help" });
+      
+      const { useKeyBindings } = await import("../../../src/hooks/useKeyBindings.ts");
+      useKeyBindings({ config: mockConfig, onRefresh: mockOnRefresh });
+      
+      simulateKeyInput("a");
+      
+      expect(mockDispatch).toHaveBeenCalledWith({
+        type: "SET_MODE",
+        payload: "normal",
+      });
+    });
+
+    test("any key closes filter-options mode", async () => {
+      setTestState({ mode: "filter-options" });
+      
+      const { useKeyBindings } = await import("../../../src/hooks/useKeyBindings.ts");
+      useKeyBindings({ config: mockConfig, onRefresh: mockOnRefresh });
+      
+      simulateKeyInput("b");
+      
+      expect(mockDispatch).toHaveBeenCalledWith({
+        type: "SET_MODE",
+        payload: "normal",
+      });
+    });
+  });
+
+  describe("Clone dialog tests", () => {
+    test("escape closes clone dialog", async () => {
+      setTestState({ mode: "clone" });
+      
+      const { useKeyBindings } = await import("../../../src/hooks/useKeyBindings.ts");
+      useKeyBindings({ config: mockConfig, onRefresh: mockOnRefresh });
+      
+      simulateKeyInput("", { escape: true });
+      
+      expect(mockDispatch).toHaveBeenCalledWith({
+        type: "HIDE_CLONE_DIALOG",
+      });
+      expect(mockDispatch).toHaveBeenCalledWith({
+        type: "SET_MODE",
+        payload: "normal",
+      });
+    });
+  });
+
+  describe("Command palette tests", () => {
+    test("escape closes command palette", async () => {
+      setTestState({ mode: "command-palette" });
+      
+      const { useKeyBindings } = await import("../../../src/hooks/useKeyBindings.ts");
+      useKeyBindings({ config: mockConfig, onRefresh: mockOnRefresh });
+      
+      simulateKeyInput("", { escape: true });
+      
+      expect(mockDispatch).toHaveBeenCalledWith({
+        type: "SET_MODE",
+        payload: "normal",
+      });
+    });
+  });
+
+  describe("Refresh tests", () => {
+    test("r triggers refresh", async () => {
+      const { useKeyBindings } = await import("../../../src/hooks/useKeyBindings.ts");
+      useKeyBindings({ config: mockConfig, onRefresh: mockOnRefresh });
+      
+      simulateKeyInput("r");
+      
+      // Wait for async operations
+      await new Promise(resolve => setTimeout(resolve, 0));
+      
+      expect(mockDispatch).toHaveBeenCalledWith({
+        type: "SET_REFRESHING",
+        payload: true,
+      });
+      expect(mockOnRefresh).toHaveBeenCalled();
+      expect(mockDispatch).toHaveBeenCalledWith({
+        type: "SET_REFRESHING",
+        payload: false,
+      });
+      expect(mockDispatch).toHaveBeenCalledWith({
+        type: "SET_MESSAGE",
+        payload: "Refresh complete",
+      });
+    });
+  });
+});
+
+// Restore all mocks after all tests complete
+afterAll(() => {
+  mock.restore();
+});