@akiojin/gwt 2.0.0

package/src/cli/ui/__tests__/hooks/useGitData.test.ts.skip

@@ -0,0 +1,228 @@
+/**
+ * @vitest-environment happy-dom
+ */
+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('useGitData', () => {
+  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();
+  });
+
+  it('should initialize with loading state', async () => {
+    (getAllBranches as ReturnType<typeof vi.fn>).mockResolvedValue([]);
+    (listAdditionalWorktrees as ReturnType<typeof vi.fn>).mockResolvedValue([]);
+
+    const { result } = renderHook(() => useGitData());
+
+    // In test environment, useEffect runs synchronously, so loading may already be false
+    // Check that it eventually becomes false and data is loaded
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+    });
+
+    expect(result.current.branches).toEqual([]);
+    expect(result.current.worktrees).toEqual([]);
+    expect(result.current.error).toBeNull();
+  });
+
+  it('should load branches and worktrees', async () => {
+    const mockBranches: BranchInfo[] = [
+      {
+        name: 'main',
+        type: 'local',
+        branchType: 'main',
+        isCurrent: true,
+      },
+      {
+        name: 'feature/test',
+        type: 'local',
+        branchType: 'feature',
+        isCurrent: false,
+      },
+    ];
+
+    const mockWorktrees = [
+      {
+        path: '/path/to/worktree',
+        branch: 'feature/test',
+        head: 'abc123',
+        isAccessible: true,
+      },
+    ];
+
+    (getAllBranches as ReturnType<typeof vi.fn>).mockResolvedValue(mockBranches);
+    (listAdditionalWorktrees as ReturnType<typeof vi.fn>).mockResolvedValue(mockWorktrees);
+
+    const { result } = renderHook(() => useGitData());
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+    });
+
+    expect(result.current.branches).toHaveLength(2);
+    expect(result.current.branches[1].worktree).toBeDefined();
+    expect(result.current.branches[1].worktree?.path).toBe('/path/to/worktree');
+    expect(result.current.worktrees).toHaveLength(1);
+    expect(result.current.worktrees[0].branch).toBe('feature/test');
+    expect(result.current.error).toBeNull();
+  });
+
+  it('should handle errors', async () => {
+    (getAllBranches as ReturnType<typeof vi.fn>).mockRejectedValue(new Error('Git error'));
+    (listAdditionalWorktrees as ReturnType<typeof vi.fn>).mockResolvedValue([]);
+
+    const { result } = renderHook(() => useGitData());
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+    });
+
+    expect(result.current.error).toBeDefined();
+    expect(result.current.error?.message).toBe('Git error');
+    expect(result.current.branches).toEqual([]);
+    expect(result.current.worktrees).toEqual([]);
+  });
+
+  it('should support manual refresh', async () => {
+    const mockBranches: BranchInfo[] = [
+      {
+        name: 'main',
+        type: 'local',
+        branchType: 'main',
+        isCurrent: true,
+      },
+    ];
+
+    (getAllBranches as ReturnType<typeof vi.fn>).mockResolvedValue(mockBranches);
+    (listAdditionalWorktrees as ReturnType<typeof vi.fn>).mockResolvedValue([]);
+
+    const { result } = renderHook(() => useGitData());
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+    });
+
+    expect(result.current.branches).toHaveLength(1);
+
+    // Add a new branch
+    const updatedBranches: BranchInfo[] = [
+      ...mockBranches,
+      {
+        name: 'feature/new',
+        type: 'local',
+        branchType: 'feature',
+        isCurrent: false,
+      },
+    ];
+
+    (getAllBranches as ReturnType<typeof vi.fn>).mockResolvedValue(updatedBranches);
+
+    // Trigger refresh
+    result.current.refresh();
+
+    await waitFor(() => {
+      expect(result.current.branches).toHaveLength(2);
+    });
+  });
+
+  it('should match worktrees to branches by name', async () => {
+    const mockBranches: BranchInfo[] = [
+      {
+        name: 'feature/a',
+        type: 'local',
+        branchType: 'feature',
+        isCurrent: false,
+      },
+      {
+        name: 'feature/b',
+        type: 'local',
+        branchType: 'feature',
+        isCurrent: false,
+      },
+      {
+        name: 'feature/c',
+        type: 'local',
+        branchType: 'feature',
+        isCurrent: false,
+      },
+    ];
+
+    const mockWorktrees = [
+      {
+        path: '/path/a',
+        branch: 'feature/a',
+        head: 'aaa',
+        isAccessible: true,
+      },
+      {
+        path: '/path/c',
+        branch: 'feature/c',
+        head: 'ccc',
+        isAccessible: false,
+        invalidReason: 'Path does not exist',
+      },
+    ];
+
+    (getAllBranches as ReturnType<typeof vi.fn>).mockResolvedValue(mockBranches);
+    (listAdditionalWorktrees as ReturnType<typeof vi.fn>).mockResolvedValue(mockWorktrees);
+
+    const { result } = renderHook(() => useGitData());
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+    });
+
+    const branchA = result.current.branches.find((b) => b.name === 'feature/a');
+    const branchB = result.current.branches.find((b) => b.name === 'feature/b');
+    const branchC = result.current.branches.find((b) => b.name === 'feature/c');
+
+    expect(branchA?.worktree).toBeDefined();
+    expect(branchA?.worktree?.path).toBe('/path/a');
+
+    expect(branchB?.worktree).toBeUndefined();
+
+    expect(branchC?.worktree).toBeDefined();
+    expect(branchC?.worktree?.path).toBe('/path/c');
+  });
+
+  it('should set lastUpdated after loading data', async () => {
+    (getAllBranches as ReturnType<typeof vi.fn>).mockResolvedValue([]);
+    (listAdditionalWorktrees as ReturnType<typeof vi.fn>).mockResolvedValue([]);
+
+    const { result } = renderHook(() => useGitData());
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+    });
+
+    expect(result.current.lastUpdated).toBeInstanceOf(Date);
+  });
+
+  // Note: Auto-refresh tests removed due to flakiness in parallel execution
+  // The auto-refresh functionality is thoroughly tested in:
+  // - src/ui/__tests__/integration/realtimeUpdate.test.tsx
+  // - src/ui/__tests__/acceptance/realtimeUpdate.acceptance.test.tsx
+  // These tests pass when run in isolation but fail in parallel due to timer precision issues
+});

package/src/cli/ui/__tests__/hooks/useScreenState.test.ts

@@ -0,0 +1,146 @@
+/**
+ * @vitest-environment happy-dom
+ */
+import { describe, it, expect, beforeEach } from "vitest";
+import { renderHook, act } from "@testing-library/react";
+import { useScreenState } from "../../hooks/useScreenState.js";
+import type { ScreenType } from "../../types.js";
+import { Window } from "happy-dom";
+
+describe("useScreenState", () => {
+  beforeEach(() => {
+    // Setup happy-dom
+    const window = new Window();
+    globalThis.window = window as any;
+    globalThis.document = window.document as any;
+  });
+  it("should initialize with branch-list as active screen", () => {
+    const { result } = renderHook(() => useScreenState());
+
+    expect(result.current.currentScreen).toBe("branch-list");
+  });
+
+  it("should navigate to a new screen", () => {
+    const { result } = renderHook(() => useScreenState());
+
+    act(() => {
+      result.current.navigateTo("worktree-manager");
+    });
+
+    expect(result.current.currentScreen).toBe("worktree-manager");
+  });
+
+  it("should navigate back to previous screen", () => {
+    const { result } = renderHook(() => useScreenState());
+
+    act(() => {
+      result.current.navigateTo("worktree-manager");
+    });
+
+    expect(result.current.currentScreen).toBe("worktree-manager");
+
+    act(() => {
+      result.current.goBack();
+    });
+
+    expect(result.current.currentScreen).toBe("branch-list");
+  });
+
+  it("should maintain screen history", () => {
+    const { result } = renderHook(() => useScreenState());
+
+    act(() => {
+      result.current.navigateTo("worktree-manager");
+    });
+
+    act(() => {
+      result.current.navigateTo("branch-creator");
+    });
+
+    expect(result.current.currentScreen).toBe("branch-creator");
+
+    act(() => {
+      result.current.goBack();
+    });
+
+    expect(result.current.currentScreen).toBe("worktree-manager");
+
+    act(() => {
+      result.current.goBack();
+    });
+
+    expect(result.current.currentScreen).toBe("branch-list");
+  });
+
+  it("should not go back when at initial screen", () => {
+    const { result } = renderHook(() => useScreenState());
+
+    expect(result.current.currentScreen).toBe("branch-list");
+
+    act(() => {
+      result.current.goBack();
+    });
+
+    expect(result.current.currentScreen).toBe("branch-list");
+  });
+
+  it("should handle multiple navigations correctly", () => {
+    const { result } = renderHook(() => useScreenState());
+
+    const screens: ScreenType[] = [
+      "worktree-manager",
+      "branch-creator",
+      "ai-tool-selector",
+      "execution-mode-selector",
+    ];
+
+    screens.forEach((screen) => {
+      act(() => {
+        result.current.navigateTo(screen);
+      });
+    });
+
+    expect(result.current.currentScreen).toBe("execution-mode-selector");
+
+    // Go back through all screens
+    act(() => {
+      result.current.goBack();
+    });
+    expect(result.current.currentScreen).toBe("ai-tool-selector");
+
+    act(() => {
+      result.current.goBack();
+    });
+    expect(result.current.currentScreen).toBe("branch-creator");
+
+    act(() => {
+      result.current.goBack();
+    });
+    expect(result.current.currentScreen).toBe("worktree-manager");
+
+    act(() => {
+      result.current.goBack();
+    });
+    expect(result.current.currentScreen).toBe("branch-list");
+  });
+
+  it("should reset to initial screen", () => {
+    const { result } = renderHook(() => useScreenState());
+
+    act(() => {
+      result.current.navigateTo("worktree-manager");
+    });
+
+    act(() => {
+      result.current.navigateTo("branch-creator");
+    });
+
+    expect(result.current.currentScreen).toBe("branch-creator");
+
+    act(() => {
+      result.current.reset();
+    });
+
+    expect(result.current.currentScreen).toBe("branch-list");
+  });
+});

package/src/cli/ui/__tests__/hooks/useTerminalSize.test.ts

@@ -0,0 +1,98 @@
+/**
+ * @vitest-environment happy-dom
+ */
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { renderHook, act } from "@testing-library/react";
+import { useTerminalSize } from "../../hooks/useTerminalSize.js";
+import { Window } from "happy-dom";
+
+describe("useTerminalSize", () => {
+  const originalRows = process.stdout.rows;
+  const originalColumns = process.stdout.columns;
+
+  beforeEach(() => {
+    // Setup happy-dom
+    const window = new Window();
+    globalThis.window = window as any;
+    globalThis.document = window.document as any;
+
+    // デフォルト値を設定
+    process.stdout.rows = 24;
+    process.stdout.columns = 80;
+  });
+
+  afterEach(() => {
+    // 元の値に戻す
+    process.stdout.rows = originalRows;
+    process.stdout.columns = originalColumns;
+    vi.restoreAllMocks();
+  });
+
+  it("should return current terminal size", () => {
+    const { result } = renderHook(() => useTerminalSize());
+
+    expect(result.current.rows).toBe(24);
+    expect(result.current.columns).toBe(80);
+  });
+
+  it("should use default values when stdout properties are undefined", () => {
+    process.stdout.rows = undefined as any;
+    process.stdout.columns = undefined as any;
+
+    const { result } = renderHook(() => useTerminalSize());
+
+    expect(result.current.rows).toBe(24); // デフォルト値
+    expect(result.current.columns).toBe(80); // デフォルト値
+  });
+
+  it("should update size when resize event is emitted", () => {
+    const { result } = renderHook(() => useTerminalSize());
+
+    expect(result.current.rows).toBe(24);
+    expect(result.current.columns).toBe(80);
+
+    act(() => {
+      process.stdout.rows = 30;
+      process.stdout.columns = 120;
+      process.stdout.emit("resize");
+    });
+
+    expect(result.current.rows).toBe(30);
+    expect(result.current.columns).toBe(120);
+  });
+
+  it("should cleanup resize listener on unmount", () => {
+    const removeListenerSpy = vi.spyOn(process.stdout, "removeListener");
+
+    const { unmount } = renderHook(() => useTerminalSize());
+
+    unmount();
+
+    expect(removeListenerSpy).toHaveBeenCalledWith(
+      "resize",
+      expect.any(Function),
+    );
+  });
+
+  it("should handle multiple resize events", () => {
+    const { result } = renderHook(() => useTerminalSize());
+
+    act(() => {
+      process.stdout.rows = 40;
+      process.stdout.columns = 100;
+      process.stdout.emit("resize");
+    });
+
+    expect(result.current.rows).toBe(40);
+    expect(result.current.columns).toBe(100);
+
+    act(() => {
+      process.stdout.rows = 50;
+      process.stdout.columns = 150;
+      process.stdout.emit("resize");
+    });
+
+    expect(result.current.rows).toBe(50);
+    expect(result.current.columns).toBe(150);
+  });
+});