gitforest 0.1.0 → 1.0.0

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

@@ -1,83 +0,0 @@
-/**
- * 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

@@ -1,239 +0,0 @@
-/**
- * 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

@@ -1,81 +0,0 @@
-/**
- * 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);
-    });
-  });
-});