@akiojin/gwt 4.9.1 → 4.11.6

package/src/cli/ui/__tests__/integration/realtimeUpdate.test.tsx.skip

@@ -1,216 +0,0 @@
-/**
- * @vitest-environment happy-dom
- * Integration tests for realtime update functionality
- */
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { renderHook, waitFor } from '@testing-library/react';
-import { useGitData } from '../../hooks/useGitData.js';
-import { Window } from 'happy-dom';
-import type { BranchInfo } from '../../types.js';
-
-// Mock git.js and worktree.js
-vi.mock('../../../git.js', () => ({
-  getAllBranches: vi.fn(),
-}));
-
-vi.mock('../../../worktree.js', () => ({
-  listAdditionalWorktrees: vi.fn(),
-}));
-
-import { getAllBranches } from '../../../git.js';
-import { listAdditionalWorktrees } from '../../../worktree.js';
-
-describe('Realtime Update Integration Tests', () => {
-  beforeEach(() => {
-    // Setup happy-dom
-    const window = new Window();
-    globalThis.window = window as any;
-    globalThis.document = window.document as any;
-
-    // Reset mocks
-    (getAllBranches as ReturnType<typeof vi.fn>).mockReset();
-    (listAdditionalWorktrees as ReturnType<typeof vi.fn>).mockReset();
-  });
-
-  const mockBranches: BranchInfo[] = [
-    {
-      name: 'main',
-      type: 'local',
-      branchType: 'main',
-      isCurrent: true,
-    },
-  ];
-
-  it('should update lastUpdated timestamp after data refresh', async () => {
-    (getAllBranches as ReturnType<typeof vi.fn>).mockResolvedValue(mockBranches);
-    (listAdditionalWorktrees as ReturnType<typeof vi.fn>).mockResolvedValue([]);
-
-    const { result } = renderHook(() => useGitData());
-
-    // Wait for initial load
-    await waitFor(() => {
-      expect(result.current.loading).toBe(false);
-    });
-
-    const firstUpdated = result.current.lastUpdated;
-    expect(firstUpdated).toBeInstanceOf(Date);
-
-    // Wait to ensure timestamp difference (increased from 50ms to 100ms)
-    await new Promise((resolve) => setTimeout(resolve, 100));
-
-    // Trigger manual refresh
-    result.current.refresh();
-
-    await waitFor(() => {
-      expect(result.current.loading).toBe(false);
-    });
-
-    const secondUpdated = result.current.lastUpdated;
-    expect(secondUpdated).toBeInstanceOf(Date);
-    // Use greaterThanOrEqual to handle rare cases where timestamps are identical
-    expect(secondUpdated!.getTime()).toBeGreaterThanOrEqual(firstUpdated!.getTime());
-  });
-
-  it('should maintain data consistency during auto-refresh', async () => {
-    let callCount = 0;
-    (getAllBranches as ReturnType<typeof vi.fn>).mockImplementation(async () => {
-      callCount++;
-      if (callCount === 1) {
-        return mockBranches;
-      }
-      // Return updated branches on subsequent calls
-      return [
-        ...mockBranches,
-        {
-          name: 'feature/new',
-          type: 'local',
-          branchType: 'feature',
-          isCurrent: false,
-        },
-      ];
-    });
-    (listAdditionalWorktrees as ReturnType<typeof vi.fn>).mockResolvedValue([]);
-
-    const { result } = renderHook(() =>
-      useGitData({ enableAutoRefresh: true, refreshInterval: 100 })
-    );
-
-    // Wait for initial load
-    await waitFor(() => {
-      expect(result.current.loading).toBe(false);
-    });
-
-    expect(result.current.branches).toHaveLength(1);
-
-    // Wait for auto-refresh to trigger
-    await new Promise((resolve) => setTimeout(resolve, 150));
-
-    await waitFor(() => {
-      expect(result.current.branches).toHaveLength(2);
-    });
-
-    // Verify data integrity
-    expect(result.current.branches[0].name).toBe('main');
-    expect(result.current.branches[1].name).toBe('feature/new');
-    expect(result.current.error).toBeNull();
-  });
-
-  it('should handle errors during auto-refresh gracefully', async () => {
-    let callCount = 0;
-    (getAllBranches as ReturnType<typeof vi.fn>).mockImplementation(async () => {
-      callCount++;
-      if (callCount === 1) {
-        return mockBranches;
-      }
-      // Simulate error on second call
-      throw new Error('Network error');
-    });
-    (listAdditionalWorktrees as ReturnType<typeof vi.fn>).mockResolvedValue([]);
-
-    const { result } = renderHook(() =>
-      useGitData({ enableAutoRefresh: true, refreshInterval: 100 })
-    );
-
-    // Wait for initial load
-    await waitFor(() => {
-      expect(result.current.loading).toBe(false);
-    });
-
-    expect(result.current.branches).toHaveLength(1);
-    expect(result.current.error).toBeNull();
-
-    // Wait for auto-refresh to trigger and fail
-    await new Promise((resolve) => setTimeout(resolve, 150));
-
-    await waitFor(() => {
-      expect(result.current.error).not.toBeNull();
-    });
-
-    expect(result.current.error?.message).toBe('Network error');
-    // Data should be cleared on error
-    expect(result.current.branches).toEqual([]);
-  });
-
-  it('should stop auto-refresh when component unmounts', async () => {
-    (getAllBranches as ReturnType<typeof vi.fn>).mockResolvedValue(mockBranches);
-    (listAdditionalWorktrees as ReturnType<typeof vi.fn>).mockResolvedValue([]);
-
-    const { result, unmount } = renderHook(() =>
-      useGitData({ enableAutoRefresh: true, refreshInterval: 100 })
-    );
-
-    // Wait for initial load
-    await waitFor(() => {
-      expect(result.current.loading).toBe(false);
-    });
-
-    const initialCallCount = (getAllBranches as ReturnType<typeof vi.fn>).mock.calls.length;
-
-    // Unmount the hook
-    unmount();
-
-    // Wait longer than refresh interval
-    await new Promise((resolve) => setTimeout(resolve, 200));
-
-    // Call count should not increase after unmount
-    const finalCallCount = (getAllBranches as ReturnType<typeof vi.fn>).mock.calls.length;
-    expect(finalCallCount).toBe(initialCallCount);
-  });
-
-  it('should update statistics in real-time', async () => {
-    let callCount = 0;
-    (getAllBranches as ReturnType<typeof vi.fn>).mockImplementation(async () => {
-      callCount++;
-      if (callCount === 1) {
-        return [mockBranches[0]];
-      }
-      // Return more branches on subsequent calls
-      return [
-        mockBranches[0],
-        { name: 'feature/a', type: 'local', branchType: 'feature', isCurrent: false },
-        { name: 'feature/b', type: 'local', branchType: 'feature', isCurrent: false },
-      ];
-    });
-    (listAdditionalWorktrees as ReturnType<typeof vi.fn>).mockResolvedValue([]);
-
-    const { result } = renderHook(() =>
-      useGitData({ enableAutoRefresh: true, refreshInterval: 100 })
-    );
-
-    // Wait for initial load
-    await waitFor(() => {
-      expect(result.current.loading).toBe(false);
-    });
-
-    expect(result.current.branches).toHaveLength(1);
-
-    // Wait for auto-refresh
-    await new Promise((resolve) => setTimeout(resolve, 150));
-
-    await waitFor(() => {
-      expect(result.current.branches).toHaveLength(3);
-    });
-
-    expect(result.current.lastUpdated).toBeInstanceOf(Date);
-  });
-});

package/src/cli/ui/__tests__/performance/branchList.performance.test.tsx

@@ -1,193 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { render } from "ink-testing-library";
-import React from "react";
-import { BranchListScreen } from "../../components/screens/BranchListScreen.js";
-import type { BranchItem, Statistics } from "../../types.js";
-
-const isCI = Boolean(process.env.CI);
-const describeFn = isCI ? describe.skip : describe;
-
-/**
- * Generate mock branch items for performance testing
- */
-function generateMockBranches(count: number): BranchItem[] {
-  const branches: BranchItem[] = [];
-  const types = ["feature", "hotfix", "release", "other"] as const;
-  const branchTypes = [
-    "main",
-    "develop",
-    "feature",
-    "hotfix",
-    "release",
-    "other",
-  ] as const;
-
-  for (let i = 0; i < count; i++) {
-    const type = types[i % types.length];
-    const branchType = branchTypes[i % branchTypes.length];
-    const hasWorktree = i % 3 === 0;
-
-    branches.push({
-      name: `${type}/test-branch-${i.toString().padStart(4, "0")}`,
-      branchType,
-      type: i % 10 === 0 ? "remote" : "local",
-      isCurrent: i === 0,
-      worktree: hasWorktree
-        ? {
-            path: `/mock/worktree/${type}-${i}`,
-            branch: `${type}/test-branch-${i.toString().padStart(4, "0")}`,
-            isAccessible: i % 5 !== 0, // Some inaccessible
-          }
-        : undefined,
-      worktreeStatus: hasWorktree
-        ? i % 5 !== 0
-          ? "active"
-          : "inaccessible"
-        : undefined,
-      hasChanges: i % 4 === 0,
-      icons: [],
-      label: `${type}/test-branch-${i.toString().padStart(4, "0")}`,
-      value: `${type}/test-branch-${i.toString().padStart(4, "0")}`,
-    });
-  }
-
-  return branches;
-}
-
-// Unused for now - keeping for potential future use
-// const mockStats: Statistics = {
-//   total: 0,
-//   local: 0,
-//   remote: 0,
-//   current: 0,
-//   feature: 0,
-//   hotfix: 0,
-//   release: 0,
-//   worktree: 0,
-// };
-
-describeFn("BranchListScreen Performance", () => {
-  it("should render 100+ branches within acceptable time", () => {
-    const branches = generateMockBranches(150);
-    const stats: Statistics = {
-      total: branches.length,
-      local: branches.filter((b) => b.type === "local").length,
-      remote: branches.filter((b) => b.type === "remote").length,
-      current: 1,
-      feature: branches.filter((b) => b.branchType === "feature").length,
-      hotfix: branches.filter((b) => b.branchType === "hotfix").length,
-      release: branches.filter((b) => b.branchType === "release").length,
-      worktree: branches.filter((b) => b.worktree).length,
-    };
-
-    const startTime = performance.now();
-
-    const { unmount } = render(
-      <BranchListScreen
-        branches={branches}
-        stats={stats}
-        onSelect={() => {}}
-        onQuit={() => {}}
-      />,
-    );
-
-    const renderTime = performance.now() - startTime;
-
-    unmount();
-
-    // Rendering should complete within 500ms (generous threshold)
-    expect(renderTime).toBeLessThan(500);
-
-    // Log performance metrics
-    console.log(`\n📊 Performance Test Results:`);
-    console.log(`   Branches: ${branches.length}`);
-    console.log(`   Render time: ${renderTime.toFixed(2)}ms`);
-    console.log(
-      `   Average per branch: ${(renderTime / branches.length).toFixed(3)}ms`,
-    );
-  });
-
-  it("should handle re-render efficiently when stats update", () => {
-    const branches = generateMockBranches(100);
-    const stats: Statistics = {
-      total: branches.length,
-      local: branches.filter((b) => b.type === "local").length,
-      remote: branches.filter((b) => b.type === "remote").length,
-      current: 1,
-      feature: branches.filter((b) => b.branchType === "feature").length,
-      hotfix: branches.filter((b) => b.branchType === "hotfix").length,
-      release: branches.filter((b) => b.branchType === "release").length,
-      worktree: branches.filter((b) => b.worktree).length,
-    };
-
-    const { rerender, unmount } = render(
-      <BranchListScreen
-        branches={branches}
-        stats={stats}
-        onSelect={() => {}}
-        onQuit={() => {}}
-        lastUpdated={new Date()}
-      />,
-    );
-
-    // Simulate stats update (real-time refresh)
-    const startTime = performance.now();
-
-    rerender(
-      <BranchListScreen
-        branches={branches}
-        stats={{ ...stats, total: stats.total + 1 }}
-        onSelect={() => {}}
-        onQuit={() => {}}
-        lastUpdated={new Date()}
-      />,
-    );
-
-    const rerenderTime = performance.now() - startTime;
-
-    unmount();
-
-    // Performance threshold for re-render
-    const threshold = 100;
-    expect(rerenderTime).toBeLessThan(threshold);
-
-    console.log(`\n🔄 Re-render Performance:`);
-    console.log(`   Re-render time: ${rerenderTime.toFixed(2)}ms`);
-  });
-
-  it("should handle large branch list (200+ branches)", () => {
-    const branches = generateMockBranches(250);
-    const stats: Statistics = {
-      total: branches.length,
-      local: branches.filter((b) => b.type === "local").length,
-      remote: branches.filter((b) => b.type === "remote").length,
-      current: 1,
-      feature: branches.filter((b) => b.branchType === "feature").length,
-      hotfix: branches.filter((b) => b.branchType === "hotfix").length,
-      release: branches.filter((b) => b.branchType === "release").length,
-      worktree: branches.filter((b) => b.worktree).length,
-    };
-
-    const startTime = performance.now();
-
-    const { unmount } = render(
-      <BranchListScreen
-        branches={branches}
-        stats={stats}
-        onSelect={() => {}}
-        onQuit={() => {}}
-      />,
-    );
-
-    const renderTime = performance.now() - startTime;
-
-    unmount();
-
-    // Even with 250+ branches, should render within 1 second
-    expect(renderTime).toBeLessThan(1000);
-
-    console.log(`\n🚀 Large Branch List Performance:`);
-    console.log(`   Branches: ${branches.length}`);
-    console.log(`   Render time: ${renderTime.toFixed(2)}ms`);
-  });
-});

package/src/cli/ui/__tests__/performance/useMemoOptimization.test.tsx

@@ -1,234 +0,0 @@
-/**
- * @vitest-environment happy-dom
- */
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { render } from "@testing-library/react";
-import React, { useMemo } from "react";
-import { Window } from "happy-dom";
-import type { BranchInfo, WorktreeInfo } from "../../types.js";
-import { formatBranchItems } from "../../utils/branchFormatter.js";
-
-/**
- * T082-1: useMemo optimization tests
- * Tests that branchItems are not unnecessarily regenerated when data content is the same
- */
-
-// Mock useGitData hook
-vi.mock("../../hooks/useGitData.js", () => ({
-  useGitData: vi.fn(),
-}));
-
-// Helper function to create a stable hash of branch data
-function createBranchHash(branches: BranchInfo[]): string {
-  return branches.map((b) => `${b.name}-${b.type}-${b.isCurrent}`).join(",");
-}
-
-// Helper function to create a stable hash of worktree data
-function createWorktreeHash(worktrees: WorktreeInfo[]): string {
-  return worktrees.map((w) => `${w.branch}-${w.path}`).join(",");
-}
-
-// Test component that uses optimized useMemo
-function TestComponent({
-  branches,
-  worktrees,
-}: {
-  branches: BranchInfo[];
-  worktrees: WorktreeInfo[];
-}) {
-  // Count how many times formatBranchItems is called
-  const formatCallCount = React.useRef(0);
-
-  // Optimized useMemo with content-based dependencies
-  const branchItems = useMemo(() => {
-    formatCallCount.current++;
-    const worktreeMap = new Map();
-    for (const wt of worktrees) {
-      worktreeMap.set(wt.branch, {
-        path: wt.path,
-        locked: false,
-        prunable: wt.isAccessible === false,
-        isAccessible: wt.isAccessible ?? true,
-      });
-    }
-    return formatBranchItems(branches, worktreeMap);
-  }, [createBranchHash(branches), createWorktreeHash(worktrees)]);
-
-  return <div data-testid="branch-count">{branchItems.length}</div>;
-}
-
-describe("useMemo Optimization (T082-1)", () => {
-  beforeEach(() => {
-    const window = new Window();
-    globalThis.window = window as unknown as typeof globalThis.window;
-    globalThis.document =
-      window.document as unknown as typeof globalThis.document;
-    vi.clearAllMocks();
-  });
-
-  it("should not regenerate branchItems when data content is the same", () => {
-    const mockBranches: BranchInfo[] = [
-      {
-        name: "main",
-        branchType: "main",
-        type: "local",
-        isCurrent: true,
-      },
-      {
-        name: "feature/test-1",
-        branchType: "feature",
-        type: "local",
-        isCurrent: false,
-      },
-    ];
-
-    const mockWorktrees: WorktreeInfo[] = [
-      {
-        path: "/mock/worktree/feature-test-1",
-        branch: "feature/test-1",
-        isAccessible: true,
-      },
-    ];
-
-    const { rerender } = render(
-      <TestComponent branches={mockBranches} worktrees={mockWorktrees} />,
-    );
-
-    // Create new arrays with the same content
-    const sameBranches: BranchInfo[] = [
-      {
-        name: "main",
-        branchType: "main",
-        type: "local",
-        isCurrent: true,
-      },
-      {
-        name: "feature/test-1",
-        branchType: "feature",
-        type: "local",
-        isCurrent: false,
-      },
-    ];
-
-    const sameWorktrees: WorktreeInfo[] = [
-      {
-        path: "/mock/worktree/feature-test-1",
-        branch: "feature/test-1",
-        isAccessible: true,
-      },
-    ];
-
-    // Verify that arrays are different references
-    expect(sameBranches).not.toBe(mockBranches);
-    expect(sameWorktrees).not.toBe(mockWorktrees);
-
-    // Verify that content is the same
-    expect(createBranchHash(sameBranches)).toBe(createBranchHash(mockBranches));
-    expect(createWorktreeHash(sameWorktrees)).toBe(
-      createWorktreeHash(mockWorktrees),
-    );
-
-    // Re-render with same content but different references
-    rerender(
-      <TestComponent branches={sameBranches} worktrees={sameWorktrees} />,
-    );
-
-    // formatBranchItems should only be called once (not twice)
-    // This test would fail with the current implementation because useMemo
-    // depends on array references, not content
-  });
-
-  it("should regenerate branchItems when data content changes", () => {
-    const initialBranches: BranchInfo[] = [
-      {
-        name: "main",
-        branchType: "main",
-        type: "local",
-        isCurrent: true,
-      },
-    ];
-
-    const { rerender } = render(
-      <TestComponent branches={initialBranches} worktrees={[]} />,
-    );
-
-    // Add a new branch
-    const updatedBranches: BranchInfo[] = [
-      ...initialBranches,
-      {
-        name: "feature/new",
-        branchType: "feature",
-        type: "local",
-        isCurrent: false,
-      },
-    ];
-
-    // Verify content changed
-    expect(createBranchHash(updatedBranches)).not.toBe(
-      createBranchHash(initialBranches),
-    );
-
-    // Re-render with new content
-    rerender(<TestComponent branches={updatedBranches} worktrees={[]} />);
-
-    // formatBranchItems should be called twice (once for initial, once for update)
-  });
-
-  it("should handle branch order changes correctly", () => {
-    const branches1: BranchInfo[] = [
-      {
-        name: "main",
-        branchType: "main",
-        type: "local",
-        isCurrent: true,
-      },
-      {
-        name: "feature/test",
-        branchType: "feature",
-        type: "local",
-        isCurrent: false,
-      },
-    ];
-
-    const branches2: BranchInfo[] = [
-      {
-        name: "feature/test",
-        branchType: "feature",
-        type: "local",
-        isCurrent: false,
-      },
-      {
-        name: "main",
-        branchType: "main",
-        type: "local",
-        isCurrent: true,
-      },
-    ];
-
-    // Different order should produce different hashes
-    expect(createBranchHash(branches1)).not.toBe(createBranchHash(branches2));
-  });
-
-  it("should detect subtle branch property changes", () => {
-    const branches1: BranchInfo[] = [
-      {
-        name: "main",
-        branchType: "main",
-        type: "local",
-        isCurrent: false,
-      },
-    ];
-
-    const branches2: BranchInfo[] = [
-      {
-        name: "main",
-        branchType: "main",
-        type: "local",
-        isCurrent: true, // Changed from false to true
-      },
-    ];
-
-    // isCurrent change should be detected
-    expect(createBranchHash(branches1)).not.toBe(createBranchHash(branches2));
-  });
-});