gitforest 0.1.0

package/test/unit/graceful-shutdown.test.ts

@@ -0,0 +1,83 @@
+/**
+ * Tests for graceful shutdown functionality
+ */
+import { describe, test, expect } from "bun:test";
+import { spawn } from "bun";
+import { join } from "path";
+
+describe("Graceful Shutdown", () => {
+  test("should register signal handlers when main module loads", async () => {
+    // Test that the main module properly registers signal handlers
+    // by spawning the process and checking it handles signals gracefully
+
+    const gitforestPath = join(import.meta.dir, "../../src/index.tsx");
+    const proc = spawn(["bun", gitforestPath, "--help"], {
+      stdout: "pipe",
+      stderr: "pipe",
+    });
+
+    let stdout = "";
+    let stderr = "";
+
+    for await (const chunk of proc.stdout) {
+      stdout += new TextDecoder().decode(chunk);
+    }
+
+    for await (const chunk of proc.stderr) {
+      stderr += new TextDecoder().decode(chunk);
+    }
+
+    const exitCode = await proc.exited;
+
+    // Should exit cleanly with code 0
+    expect(exitCode).toBe(0);
+
+    // Should show help text
+    expect(stdout).toContain("gitforest - Git Repository Manager");
+    expect(stdout).toContain("Usage:");
+  }, { timeout: 5000 });
+
+  test("should handle multiple shutdown attempts gracefully", async () => {
+    // Test the isShuttingDown flag behavior by simulating the pattern
+    let isShuttingDown = false;
+    let shutdownCount = 0;
+
+    const gracefulShutdown = async (_signal: string) => {
+      if (isShuttingDown) return;
+      isShuttingDown = true;
+      shutdownCount++;
+    };
+
+    // Simulate multiple rapid shutdown calls
+    await Promise.all([
+      gracefulShutdown("SIGINT"),
+      gracefulShutdown("SIGINT"),
+      gracefulShutdown("SIGTERM")
+    ]);
+
+    // With protection, only the first should execute
+    expect(shutdownCount).toBe(1);
+    expect(isShuttingDown).toBe(true);
+  });
+
+  test("should close database on shutdown", async () => {
+    // Mock the database close function to verify it's called
+    let dbClosed = false;
+    const mockCloseDb = () => {
+      dbClosed = true;
+    };
+
+    // Simulate shutdown sequence
+    const gracefulShutdown = async () => {
+      try {
+        mockCloseDb();
+      } catch (error) {
+        console.error('Error during shutdown:', error);
+      }
+    };
+
+    await gracefulShutdown();
+
+    expect(dbClosed).toBe(true);
+  });
+});

package/test/unit/hooks/useBackgroundFetch.test.tsx

@@ -0,0 +1,239 @@
+/**
+ * Tests for useBackgroundFetch hook
+ *
+ * Uses TestStoreProvider and dependency injection instead of mock.module()
+ */
+
+import { describe, test, expect, mock } from "bun:test";
+import React from "react";
+import { render } from "ink-testing-library";
+import { Text } from "ink";
+import { useBackgroundFetch } from "../../../src/hooks/useBackgroundFetch.ts";
+import { TestStoreProvider } from "../../../src/state/store.tsx";
+import { createMockUnifiedAppState } from "../mocks/index.ts";
+import type { GitforestConfig, Project, UnifiedAppState } from "../../../src/types/index.ts";
+
+// Mock config factory
+const createDefaultConfig = (): GitforestConfig => ({
+  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: [],
+});
+
+// Create mock projects
+const createGitProjectWithRemote = (id: string, name: string): Project => ({
+  id,
+  name,
+  path: `/test/${name}`,
+  type: "git",
+  projectMarker: null,
+  submodule: null,
+  lastScanned: new Date(),
+  lastModified: null,
+  status: {
+    hasUnstagedChanges: false,
+    hasStagedChanges: false,
+    hasUntrackedFiles: false,
+    modifiedCount: 0,
+    stagedCount: 0,
+    untrackedCount: 0,
+    currentBranch: "main",
+    trackingBranch: "origin/main",
+    unpushedCommits: 0,
+    unpulledCommits: 0,
+    hasRemote: true,
+    remoteUrl: "git@github.com:user/repo.git",
+    lastLocalCommit: null,
+    lastRemoteActivity: null,
+    hasCommits: true,
+    isDirty: false,
+    isAhead: false,
+    isBehind: false,
+    isOutOfSync: false,
+  },
+});
+
+/**
+ * Helper to create test component with store context
+ */
+function createTestComponent(
+  config: GitforestConfig,
+  state: UnifiedAppState,
+  mockOnRefresh: () => Promise<void>,
+  mockBatchFetch: () => Promise<any>,
+  mockDispatch: (action: any) => void,
+) {
+  const TestComponent = () => {
+    useBackgroundFetch(config, mockOnRefresh, {
+      batchFetch: mockBatchFetch,
+    });
+    return <Text>Test</Text>;
+  };
+
+  return render(
+    <TestStoreProvider initialState={state} dispatch={mockDispatch}>
+      <TestComponent />
+    </TestStoreProvider>
+  );
+}
+
+describe("useBackgroundFetch", () => {
+  describe("Configuration tests", () => {
+    test("does not run when disabled in config", () => {
+      const config = {
+        ...createDefaultConfig(),
+        cache: {
+          ...createDefaultConfig().cache,
+          enableBackgroundRefresh: false,
+        },
+      };
+
+      const mockBatchFetch = mock(() => Promise.resolve());
+      const mockOnRefresh = mock(() => Promise.resolve());
+      const mockDispatch = mock(() => {});
+
+      const state = createMockUnifiedAppState({
+        isLoading: false,
+        projects: [createGitProjectWithRemote("1", "test-repo")],
+      });
+
+      const { unmount, lastFrame } = createTestComponent(
+        config,
+        state,
+        mockOnRefresh,
+        mockBatchFetch,
+        mockDispatch
+      );
+
+      expect(lastFrame()).toContain("Test");
+
+      unmount();
+    });
+
+    test("hook renders without error when enabled", () => {
+      const config = createDefaultConfig();
+      const mockBatchFetch = mock(() => Promise.resolve());
+      const mockOnRefresh = mock(() => Promise.resolve());
+      const mockDispatch = mock(() => {});
+
+      const state = createMockUnifiedAppState({
+        isLoading: true,
+      });
+
+      const { unmount, lastFrame } = createTestComponent(
+        config,
+        state,
+        mockOnRefresh,
+        mockBatchFetch,
+        mockDispatch
+      );
+
+      expect(lastFrame()).toContain("Test");
+
+      unmount();
+    });
+  });
+
+  describe("State-based skipping tests", () => {
+    test("does not run during loading state", () => {
+      const config = createDefaultConfig();
+      const mockBatchFetch = mock(() => Promise.resolve());
+      const mockOnRefresh = mock(() => Promise.resolve());
+      const mockDispatch = mock(() => {});
+
+      const state = createMockUnifiedAppState({
+        isLoading: true,
+        projects: [createGitProjectWithRemote("1", "test-repo")],
+      });
+
+      const { unmount, lastFrame } = createTestComponent(
+        config,
+        state,
+        mockOnRefresh,
+        mockBatchFetch,
+        mockDispatch
+      );
+
+      expect(lastFrame()).toContain("Test");
+      // Should not have dispatched any actions since loading
+      expect(mockDispatch).not.toHaveBeenCalled();
+
+      unmount();
+    });
+
+    test("does not run during action in progress", () => {
+      const config = createDefaultConfig();
+      const mockBatchFetch = mock(() => Promise.resolve());
+      const mockOnRefresh = mock(() => Promise.resolve());
+      const mockDispatch = mock(() => {});
+
+      const state = createMockUnifiedAppState({
+        isLoading: false,
+        actionInProgress: "some-action",
+        projects: [createGitProjectWithRemote("1", "test-repo")],
+      });
+
+      const { unmount, lastFrame } = createTestComponent(
+        config,
+        state,
+        mockOnRefresh,
+        mockBatchFetch,
+        mockDispatch
+      );
+
+      expect(lastFrame()).toContain("Test");
+      // Should not have dispatched since action in progress
+      expect(mockDispatch).not.toHaveBeenCalled();
+
+      unmount();
+    });
+  });
+
+  describe("Return value tests", () => {
+    test("returns null", () => {
+      const config = createDefaultConfig();
+      const mockBatchFetch = mock(() => Promise.resolve());
+      const mockOnRefresh = mock(() => Promise.resolve());
+      const mockDispatch = mock(() => {});
+
+      const state = createMockUnifiedAppState({
+        isLoading: true,
+      });
+
+      let returnValue: any;
+      const TestComponent = () => {
+        returnValue = useBackgroundFetch(config, mockOnRefresh, {
+          batchFetch: mockBatchFetch,
+        });
+        return <Text>Test</Text>;
+      };
+
+      const { unmount } = render(
+        <TestStoreProvider initialState={state} dispatch={mockDispatch}>
+          <TestComponent />
+        </TestStoreProvider>
+      );
+
+      expect(returnValue).toBeNull();
+
+      unmount();
+    });
+  });
+});

package/test/unit/hooks/useConfirmDialogActions.test.tsx

@@ -0,0 +1,81 @@
+/**
+ * Tests for useConfirmDialogActions hook
+ * 
+ * Note: React hooks can only be tested inside React components.
+ * These tests focus on the underlying operations and logic that don't
+ * require the hook context. The hook's integration is tested via 
+ * component tests and integration tests.
+ */
+
+import { describe, test, expect, mock, beforeEach } from "bun:test";
+
+// Mock git init function
+const mockInitGitInProject = mock(() => Promise.resolve({ success: true, operation: "init" as const }));
+
+// Mock GitHub service
+const mockCreateRepo = mock(() => Promise.resolve({ success: true, url: "https://github.com/test/repo" }));
+const mockArchiveRepo = mock(() => Promise.resolve({ success: true }));
+
+describe("useConfirmDialogActions operations", () => {
+  beforeEach(() => {
+    mockInitGitInProject.mockClear();
+    mockCreateRepo.mockClear();
+    mockArchiveRepo.mockClear();
+  });
+
+  describe("Git init operation", () => {
+    test("init returns success for valid directory", async () => {
+      mockInitGitInProject.mockResolvedValueOnce({ success: true, operation: "init" });
+      
+      const result = await mockInitGitInProject();
+      
+      expect(result.success).toBe(true);
+      expect(result.operation).toBe("init");
+    });
+
+    test("init returns failure for invalid directory", async () => {
+      mockInitGitInProject.mockResolvedValueOnce({ success: false, operation: "init" });
+      
+      const result = await mockInitGitInProject();
+      
+      expect(result.success).toBe(false);
+    });
+  });
+
+  describe("GitHub repo creation", () => {
+    test("creates repo successfully", async () => {
+      mockCreateRepo.mockResolvedValueOnce({ success: true, url: "https://github.com/user/repo" });
+      
+      const result = await mockCreateRepo();
+      
+      expect(result.success).toBe(true);
+      expect(result.url).toContain("github.com");
+    });
+
+    test("handles creation failure", async () => {
+      mockCreateRepo.mockResolvedValueOnce({ success: false, url: "" });
+      
+      const result = await mockCreateRepo();
+      
+      expect(result.success).toBe(false);
+    });
+  });
+
+  describe("GitHub repo archiving", () => {
+    test("archives repo successfully", async () => {
+      mockArchiveRepo.mockResolvedValueOnce({ success: true });
+      
+      const result = await mockArchiveRepo();
+      
+      expect(result.success).toBe(true);
+    });
+
+    test("handles archive failure", async () => {
+      mockArchiveRepo.mockResolvedValueOnce({ success: false });
+      
+      const result = await mockArchiveRepo();
+      
+      expect(result.success).toBe(false);
+    });
+  });
+});