gitforest 0.1.0 → 1.0.0

package/test/integration/app.isolated.tsx

@@ -1,240 +0,0 @@
-/**
- * Integration tests for the main App component
- */
-
-import { describe, test, expect, beforeEach, mock } from "bun:test";
-import { render } from "ink-testing-library";
-import { App } from "../../src/app.tsx";
-import { createMockConfig } from "../unit/mocks/config.ts";
-import { createMockUnifiedRepo } from "../unit/mocks/unified.ts";
-// Import the real utility functions to use in mocks - these don't need mocking
-import { sortProjects as realSortProjects, filterProjects as realFilterProjects } from "../../src/utils/project-utils.ts";
-
-// Mock all external dependencies
-const mockLoadUnifiedRepos = mock(() => {});
-const mockRefreshGitHub = mock(() => {});
-const mockCloneRepo = mock(() => {});
-const mockBatchClone = mock(() => {});
-const mockBackgroundRefresh = mock(() => {});
-const mockUseKeyBindings = mock(() => {});
-const mockUseBackgroundFetch = mock(() => {});
-const mockScanWithCache = mock(() => Promise.resolve([]));
-const mockFetchGitHubReposWithCache = mock(() => Promise.resolve({ repos: [], error: null }));
-const mockLoadGitHubReposFromCache = mock(() => Promise.resolve([]));
-const mockCreateUnifiedView = mock(() => []);
-const mockCloneGitHubRepo = mock(() => Promise.resolve({ success: true }));
-
-mock.module("../../src/hooks/useUnifiedRepos.ts", () => ({
-  useUnifiedRepos: mock(() => ({
-    loadUnifiedRepos: mockLoadUnifiedRepos,
-    refreshGitHub: mockRefreshGitHub,
-    cloneRepo: mockCloneRepo,
-    batchClone: mockBatchClone,
-    backgroundRefresh: mockBackgroundRefresh,
-  })),
-}));
-
-mock.module("../../src/hooks/useKeyBindings.ts", () => ({
-  useKeyBindings: mockUseKeyBindings,
-}));
-
-mock.module("../../src/hooks/useBackgroundFetch.ts", () => ({
-  useBackgroundFetch: mockUseBackgroundFetch,
-}));
-
-mock.module("../../src/scanner/index.ts", () => ({
-  scanWithCache: mockScanWithCache,
-  // Use real implementations for utility functions to avoid polluting other tests
-  sortProjects: realSortProjects,
-  filterProjects: realFilterProjects,
-}));
-
-mock.module("../../src/github/cache.ts", () => ({
-  fetchGitHubReposWithCache: mockFetchGitHubReposWithCache,
-  loadGitHubReposFromCache: mockLoadGitHubReposFromCache,
-}));
-
-mock.module("../../src/github/unified.ts", () => ({
-  createUnifiedView: mockCreateUnifiedView,
-  cloneGitHubRepo: mockCloneGitHubRepo,
-}));
-
-describe("App Integration", () => {
-  let mockConfig: any;
-
-  beforeEach(() => {
-    // Reset all mocks
-    mockLoadUnifiedRepos.mockReset();
-    mockUseKeyBindings.mockReset();
-    mockUseBackgroundFetch.mockReset();
-
-    // Create mock config
-    mockConfig = createMockConfig({
-      directories: [{ path: "/test/projects", maxDepth: 3 }],
-    });
-  });
-
-  describe("App rendering", () => {
-    test("renders without crashing", () => {
-      const { unmount } = render(<App config={mockConfig} />);
-      
-      // Should render without throwing
-      expect(() => unmount()).not.toThrow();
-    });
-
-    test("StoreProvider wraps content correctly", () => {
-      const { lastFrame } = render(<App config={mockConfig} />);
-      
-      // Should contain the app structure
-      const frame = lastFrame();
-      expect(frame).toBeTruthy();
-      expect(frame).toContain("gitforest");
-    });
-
-    test("Layout component receives correct props", () => {
-      render(<App config={mockConfig} />);
-      
-      // The Layout component should be rendered with the correct props
-      // We can verify this by checking the hooks were called with expected parameters
-      expect(mockUseKeyBindings).toHaveBeenCalledWith({
-        config: mockConfig,
-        onRefresh: mockLoadUnifiedRepos,
-      });
-    });
-
-    test("initial loading state is shown", () => {
-      const { lastFrame } = render(<App config={mockConfig} />);
-      
-      // Should show loading state initially
-      const frame = lastFrame();
-      expect(frame).toContain("Scanning projects");
-    });
-  });
-
-  describe("App initialization", () => {
-    test("projects are loaded on mount", () => {
-      render(<App config={mockConfig} />);
-      
-      // The App should render and initialize hooks
-      // We verify this by checking the Layout is rendered
-      expect(mockUseKeyBindings).toHaveBeenCalled();
-      expect(mockUseBackgroundFetch).toHaveBeenCalled();
-    });
-
-    test("keyboard bindings are set up", () => {
-      render(<App config={mockConfig} />);
-      
-      // Should set up key bindings
-      expect(mockUseKeyBindings).toHaveBeenCalledWith({
-        config: mockConfig,
-        onRefresh: mockLoadUnifiedRepos,
-      });
-    });
-
-    test("background fetch is initialized", () => {
-      render(<App config={mockConfig} />);
-      
-      // Should initialize background fetch
-      expect(mockUseBackgroundFetch).toHaveBeenCalledWith(mockConfig, mockLoadUnifiedRepos);
-    });
-  });
-
-  describe("Error handling", () => {
-    test("error state is handled gracefully", () => {
-      // Mock an error during loading
-      const errorMessage = "Failed to load projects";
-      mockLoadUnifiedRepos.mockImplementation(() => {
-        throw new Error(errorMessage);
-      });
-
-      const { lastFrame } = render(<App config={mockConfig} />);
-      
-      // Should handle error without crashing
-      const frame = lastFrame();
-      expect(frame).toBeTruthy();
-    });
-
-    test("handles missing config gracefully", () => {
-      // Test with minimal config (must have at least one directory)
-      const minimalConfig = createMockConfig({
-        directories: [{ path: "/test", maxDepth: 2 }],
-      });
-
-      const { lastFrame } = render(<App config={minimalConfig} />);
-      
-      const frame = lastFrame();
-      expect(frame).toBeTruthy();
-      expect(frame).toContain("gitforest");
-    });
-  });
-
-  describe("Clone functionality", () => {
-    test("batchClone handler is properly configured", () => {
-      const mockBatchCloneResult = mock(() => Promise.resolve({ successful: 2, failed: 0 }));
-      const useUnifiedRepos = require("../../src/hooks/useUnifiedRepos.ts").useUnifiedRepos;
-      useUnifiedRepos.mockReturnValue({
-        loadUnifiedRepos: mockLoadUnifiedRepos,
-        refreshGitHub: mock(() => {}),
-        cloneRepo: mock(() => {}),
-        batchClone: mockBatchCloneResult,
-        backgroundRefresh: mock(() => {}),
-      });
-
-      render(<App config={mockConfig} />);
-
-      // Verify the App renders without issues with the batchClone handler
-      expect(mockBatchCloneResult).toBeDefined();
-    });
-
-    test("handles clone errors gracefully", () => {
-      const mockBatchCloneError = mock(() => Promise.reject(new Error("Clone failed")));
-      const useUnifiedRepos = require("../../src/hooks/useUnifiedRepos.ts").useUnifiedRepos;
-      useUnifiedRepos.mockReturnValue({
-        loadUnifiedRepos: mockLoadUnifiedRepos,
-        refreshGitHub: mock(() => {}),
-        cloneRepo: mock(() => {}),
-        batchClone: mockBatchCloneError,
-        backgroundRefresh: mock(() => {}),
-      });
-
-      const { unmount } = render(<App config={mockConfig} />);
-      
-      // Should not crash even if clone fails
-      expect(() => unmount()).not.toThrow();
-    });
-  });
-
-  describe("State management", () => {
-    test("maintains consistent state during operations", () => {
-      // Mock loading repos
-      mockLoadUnifiedRepos.mockImplementation(() => {
-        // Simulate loading state
-        return Promise.resolve();
-      });
-
-      const { lastFrame } = render(<App config={mockConfig} />);
-      
-      // Should maintain UI consistency
-      const frame = lastFrame();
-      expect(frame).toBeTruthy();
-      expect(frame).toContain("gitforest");
-    });
-  });
-
-  describe("Performance", () => {
-    test("handles large number of repos efficiently", () => {
-      const { lastFrame } = render(<App config={mockConfig} />);
-      
-      // Should render without performance issues
-      const frame = lastFrame();
-      expect(frame).toBeTruthy();
-    });
-
-    test("properly cleans up on unmount", () => {
-      const { unmount } = render(<App config={mockConfig} />);
-      
-      // Should clean up without errors
-      expect(() => unmount()).not.toThrow();
-    });
-  });
-});

package/test/integration/cli-commands.test.ts

@@ -1,287 +0,0 @@
-import { describe, test, expect, beforeAll, afterAll } from "bun:test";
-import { $ } from "bun";
-import { join, resolve } from "path";
-import { tmpdir } from "os";
-import { mkdirSync, writeFileSync, unlinkSync, existsSync } from "fs";
-
-describe("CLI Commands Integration", () => {
-  // Use absolute path for mainPath
-  const mainPath = resolve(import.meta.dir, "../../src/index.tsx");
-  const timeout = 15000; // 15 second timeout for CLI commands
-  let testConfigPath: string;
-
-  beforeAll(async () => {
-    // Create a temporary test config directory
-    const testDir = join(tmpdir(), `gitforest-cli-test-${Date.now()}`);
-    mkdirSync(testDir, { recursive: true });
-
-    // Create gitforest subdirectory for XDG config
-    const gitforestConfigDir = join(testDir, "gitforest");
-    mkdirSync(gitforestConfigDir, { recursive: true });
-
-    // Create a test config file in XDG config location
-    testConfigPath = join(gitforestConfigDir, "config.yaml");
-    writeFileSync(testConfigPath, `
-directories:
-  - path: ${testDir}
-    maxDepth: 1
-display:
-  sortBy: name
-  sortDirection: asc
-`);
-
-    // Set environment variables for testing
-    process.env.TEST_TIMEOUT = String(timeout);
-    process.env.GITTY_IGNORE_GH = "true";
-    // Set config to our test config
-    process.env.XDG_CONFIG_HOME = testDir;
-  });
-
-  afterAll(() => {
-    // Cleanup
-    delete process.env.TEST_TIMEOUT;
-    delete process.env.GITTY_IGNORE_GH;
-    delete process.env.XDG_CONFIG_HOME;
-
-    // Clean up test config file
-    if (testConfigPath && existsSync(testConfigPath)) {
-      unlinkSync(testConfigPath);
-    }
-  });
-
-  describe("help command", () => {
-    test("shows help with --help flag", async () => {
-      const result = await $`timeout 10 bun ${mainPath} --help`.quiet().nothrow();
-      const stdout = result.stdout.toString();
-
-      expect(result.exitCode).toBe(0);
-      expect(stdout).toContain("gitforest");
-      expect(stdout).toContain("Usage");
-      expect(stdout).toContain("Commands");
-    }, { timeout });
-
-    test("shows help with -h flag", async () => {
-      const result = await $`timeout 10 bun ${mainPath} -h`.quiet().nothrow();
-      const stdout = result.stdout.toString();
-
-      expect(result.exitCode).toBe(0);
-      expect(stdout).toContain("gitforest");
-    }, { timeout });
-
-    test("lists available commands in help", async () => {
-      const result = await $`timeout 10 bun ${mainPath} --help`.quiet().nothrow();
-      const stdout = result.stdout.toString();
-
-      expect(stdout).toContain("list");
-      expect(stdout).toContain("status");
-      expect(stdout).toContain("dirty");
-      expect(stdout).toContain("pull");
-      expect(stdout).toContain("push");
-      expect(stdout).toContain("fetch");
-    }, { timeout });
-
-    test("shows GitHub commands in help", async () => {
-      const result = await $`timeout 10 bun ${mainPath} --help`.quiet().nothrow();
-      const stdout = result.stdout.toString();
-
-      expect(stdout).toContain("github");
-      expect(stdout).toContain("GITHUB_TOKEN");
-    }, { timeout });
-
-    test("shows options in help", async () => {
-      const result = await $`timeout 10 bun ${mainPath} --help`.quiet().nothrow();
-      const stdout = result.stdout.toString();
-
-      expect(stdout).toContain("--json");
-      expect(stdout).toContain("--verbose");
-      expect(stdout).toContain("--init");
-    }, { timeout });
-  });
-
-  describe("version flag", () => {
-    test("handles --version flag", async () => {
-      const result = await $`timeout 10 bun ${mainPath} --version`.quiet().nothrow();
-      // Version flag may not be implemented - just verify it doesn't hang
-      // Exit code may be 0 (success) or 1 (not implemented)
-      expect([0, 1]).toContain(result.exitCode);
-    }, { timeout });
-  });
-
-  describe("unknown command handling", () => {
-    test("shows help for unknown commands", async () => {
-      const result = await $`timeout 10 bun ${mainPath} unknowncommand`.quiet().nothrow();
-      const stdout = result.stdout.toString();
-      const stderr = result.stderr.toString();
-      const output = stdout + stderr;
-
-      // Should mention help or show an error message
-      expect(output.length).toBeGreaterThan(0);
-    }, { timeout });
-  });
-
-  describe("command output formats", () => {
-    test("list command accepts --json flag", async () => {
-      const result = await $`timeout 10 bun ${mainPath} list --json`.quiet().nothrow();
-
-      // Should not fail due to flag validation
-      expect(result.exitCode).toBe(0);
-      const stdout = result.stdout.toString();
-      // Should output JSON array
-      expect(stdout).toMatch(/\[[\s\S]*\]/);
-    }, { timeout });
-
-    test("status command accepts --json flag", async () => {
-      const result = await $`timeout 10 bun ${mainPath} status --json`.quiet().nothrow();
-
-      // Should not fail due to flag validation
-      expect(result.exitCode).toBe(0);
-      const stdout = result.stdout.toString();
-      // Should output JSON object
-      expect(stdout).toMatch(/\{[\s\S]*\}/);
-    }, { timeout });
-
-    test("dirty command accepts --json flag", async () => {
-      const result = await $`timeout 10 bun ${mainPath} dirty --json`.quiet().nothrow();
-
-      // Should not fail due to flag validation
-      expect(result.exitCode).toBe(0);
-      const stdout = result.stdout.toString();
-      // Should output JSON array
-      expect(stdout).toMatch(/\[[\s\S]*\]/);
-    }, { timeout });
-  });
-
-  describe("GitHub commands", () => {
-    test("auth command shows token status", async () => {
-      const result = await $`timeout 10 bash -c 'GITHUB_TOKEN= bun ${mainPath} auth'`.quiet().nothrow();
-
-      expect(result.exitCode).toBe(0);
-      const stdout = result.stdout.toString();
-      expect(stdout).toContain("GITHUB_TOKEN not set");
-    }, { timeout });
-
-    test("github command works without GITHUB_TOKEN but shows warning", async () => {
-      const result = await $`timeout 10 bash -c 'GITHUB_TOKEN= bun ${mainPath} github'`.quiet().nothrow();
-
-      expect(result.exitCode).toBe(1);
-      const output = result.stdout.toString() + result.stderr.toString();
-      expect(output).toContain("GitHub authentication required");
-    }, { timeout });
-
-    test("clone command works without GITHUB_TOKEN but shows warning", async () => {
-      const result = await $`timeout 10 bash -c 'GITHUB_TOKEN= bun ${mainPath} clone'`.quiet().nothrow();
-
-      // Clone command succeeds but shows warning when no repos to clone
-      expect(result.exitCode).toBe(1);
-      const output = result.stdout.toString() + result.stderr.toString();
-      expect(output).toContain("GitHub authentication required");
-    }, { timeout });
-  });
-
-  describe("filter functionality", () => {
-    test("commands accept --filter flag", async () => {
-      const commands = ["list", "status", "dirty"];
-
-      for (const cmd of commands) {
-        const result = await $`timeout 10 bun ${mainPath} ${cmd} --filter test`.quiet().nothrow();
-
-        // Should not fail due to flag validation
-        expect(result.exitCode).toBe(0);
-      }
-    }, { timeout });
-
-    test("commands accept -f short flag", async () => {
-      const commands = ["list", "status", "dirty"];
-
-      for (const cmd of commands) {
-        const result = await $`timeout 10 bun ${mainPath} ${cmd} -f test`.quiet().nothrow();
-
-        // Should not fail due to flag validation
-        expect(result.exitCode).toBe(0);
-      }
-    }, { timeout });
-  });
-
-  describe("clone command", () => {
-    test("clone accepts --target flag", async () => {
-      const result = await $`timeout 10 bash -c 'GITHUB_TOKEN= bun ${mainPath} clone --target /tmp'`.quiet().nothrow();
-
-      // Clone command succeeds but shows warning
-      expect(result.exitCode).toBe(1);
-      const output = result.stdout.toString() + result.stderr.toString();
-      expect(output).toContain("GitHub authentication required");
-    }, { timeout });
-
-    test("clone accepts -t short flag", async () => {
-      const result = await $`timeout 10 bash -c 'GITHUB_TOKEN= bun ${mainPath} clone -t /tmp'`.quiet().nothrow();
-
-      // Clone command succeeds but shows warning
-      expect(result.exitCode).toBe(1);
-      const output = result.stdout.toString() + result.stderr.toString();
-      expect(output).toContain("GitHub authentication required");
-    }, { timeout });
-
-    test("clone accepts --https flag", async () => {
-      const result = await $`timeout 10 bash -c 'GITHUB_TOKEN= bun ${mainPath} clone --https'`.quiet().nothrow();
-
-      // Clone command succeeds but shows warning
-      expect(result.exitCode).toBe(1);
-      const output = result.stdout.toString() + result.stderr.toString();
-      expect(output).toContain("GitHub authentication required");
-    }, { timeout });
-  });
-
-  describe("create-repos command", () => {
-    test("create-repos works without GITHUB_TOKEN but shows errors", async () => {
-      const result = await $`timeout 10 bash -c 'GITHUB_TOKEN= bun ${mainPath} create-repos'`.quiet().nothrow();
-
-      expect(result.exitCode).toBe(1);
-      const output = result.stdout.toString() + result.stderr.toString();
-      expect(output).toContain("GitHub authentication required");
-    }, { timeout });
-
-    test("create-repos accepts --public flag", async () => {
-      const result = await $`timeout 10 bash -c 'GITHUB_TOKEN= bun ${mainPath} create-repos --public'`.quiet().nothrow();
-
-      expect(result.exitCode).toBe(1);
-      const output = result.stdout.toString() + result.stderr.toString();
-      expect(output).toContain("GitHub authentication required");
-    }, { timeout });
-  });
-
-  describe("setup command", () => {
-    test("setup works without GITHUB_TOKEN but shows errors", async () => {
-      const result = await $`timeout 10 bash -c 'GITHUB_TOKEN= bun ${mainPath} setup'`.quiet().nothrow();
-
-      expect(result.exitCode).toBe(1);
-      const output = result.stdout.toString() + result.stderr.toString();
-      expect(output).toContain("GitHub authentication required");
-    }, { timeout });
-
-    test("setup accepts --public flag", async () => {
-      const result = await $`timeout 10 bash -c 'GITHUB_TOKEN= bun ${mainPath} setup --public'`.quiet().nothrow();
-
-      expect(result.exitCode).toBe(1);
-      const output = result.stdout.toString() + result.stderr.toString();
-      expect(output).toContain("GitHub authentication required");
-    }, { timeout });
-  });
-
-  describe("archive command", () => {
-    test("archive requires repositories argument", async () => {
-      const result = await $`timeout 10 bash -c 'GITHUB_TOKEN= bun ${mainPath} archive'`.quiet().nothrow();
-
-      expect(result.exitCode).toBe(1);
-      const stderr = result.stderr.toString();
-      expect(stderr).toContain("Please specify repositories to archive");
-    }, { timeout });
-
-    test("archive works without GITHUB_TOKEN but shows errors", async () => {
-      const result = await $`timeout 10 bash -c 'GITHUB_TOKEN= bun ${mainPath} archive repo1 repo2'`.quiet().nothrow();
-
-      expect(result.exitCode).toBe(1);
-      const output = result.stdout.toString() + result.stderr.toString();
-      expect(output).toContain("GitHub authentication required");
-    }, { timeout });
-  });
-});