@akiojin/gwt 2.9.1 → 2.10.0

package/src/cli/ui/__tests__/components/App.shortcuts.test.tsx

@@ -15,14 +15,7 @@ import { render, act, waitFor } from "@testing-library/react";
 import React from "react";
 import type { BranchItem, CleanupTarget } from "../../types.js";
 import { Window } from "happy-dom";
-import * as useGitDataModule from "../../hooks/useGitData.js";
-import * as useScreenStateModule from "../../hooks/useScreenState.js";
-import * as WorktreeManagerScreenModule from "../../components/screens/WorktreeManagerScreen.js";
-import * as BranchCreatorScreenModule from "../../components/screens/BranchCreatorScreen.js";
-import * as BranchListScreenModule from "../../components/screens/BranchListScreen.js";
-import * as worktreeModule from "../../../../worktree.ts";
-import * as gitModule from "../../../../git.ts";
-import { App } from "../../components/App.js";
+let App: typeof import("../../components/App.js").App;
 
 const navigateToMock = vi.fn();
 const goBackMock = vi.fn();
@@ -32,49 +25,77 @@ const worktreeScreenProps: any[] = [];
 const branchCreatorProps: any[] = [];
 const branchListProps: any[] = [];
 
-const originalUseGitData = useGitDataModule.useGitData;
-const originalUseScreenState = useScreenStateModule.useScreenState;
-const originalWorktreeManagerScreen =
-  WorktreeManagerScreenModule.WorktreeManagerScreen;
-const originalBranchCreatorScreen =
-  BranchCreatorScreenModule.BranchCreatorScreen;
-const originalBranchListScreen = BranchListScreenModule.BranchListScreen;
-const originalGetMergedPRWorktrees = worktreeModule.getMergedPRWorktrees;
-const originalGenerateWorktreePath = worktreeModule.generateWorktreePath;
-const originalCreateWorktree = worktreeModule.createWorktree;
-const originalRemoveWorktree = worktreeModule.removeWorktree;
-const originalGetRepositoryRoot = gitModule.getRepositoryRoot;
-const originalDeleteBranch = gitModule.deleteBranch;
-
-const useGitDataSpy = vi.spyOn(useGitDataModule, "useGitData");
-const useScreenStateSpy = vi.spyOn(useScreenStateModule, "useScreenState");
-const worktreeManagerScreenSpy = vi.spyOn(
-  WorktreeManagerScreenModule,
-  "WorktreeManagerScreen",
-);
-const branchCreatorScreenSpy = vi.spyOn(
-  BranchCreatorScreenModule,
-  "BranchCreatorScreen",
-);
-const branchListScreenSpy = vi.spyOn(
-  BranchListScreenModule,
-  "BranchListScreen",
-);
-const getMergedPRWorktreesSpy = vi.spyOn(
-  worktreeModule,
-  "getMergedPRWorktrees",
-);
-const generateWorktreePathSpy = vi.spyOn(
-  worktreeModule,
-  "generateWorktreePath",
-);
-const createWorktreeSpy = vi.spyOn(worktreeModule, "createWorktree");
-const removeWorktreeSpy = vi.spyOn(worktreeModule, "removeWorktree");
-const getRepositoryRootSpy = vi.spyOn(gitModule, "getRepositoryRoot");
-const deleteBranchSpy = vi.spyOn(gitModule, "deleteBranch");
+const useGitDataMock = vi.fn();
+const useScreenStateMock = vi.fn();
+const getMergedPRWorktreesMock = vi.fn();
+const generateWorktreePathMock = vi.fn();
+const createWorktreeMock = vi.fn();
+const removeWorktreeMock = vi.fn();
+const getRepositoryRootMock = vi.fn();
+const deleteBranchMock = vi.fn();
+
+vi.mock("../../hooks/useGitData.js", () => ({
+  useGitData: (...args: any[]) => useGitDataMock(...args),
+}));
+
+vi.mock("../../hooks/useScreenState.js", () => ({
+  useScreenState: (...args: any[]) => useScreenStateMock(...args),
+}));
+
+vi.mock("../../../../worktree.js", async () => {
+  const actual = await vi.importActual<
+    typeof import("../../../../worktree.js")
+  >("../../../../worktree.js");
+  return {
+    ...actual,
+    getMergedPRWorktrees: getMergedPRWorktreesMock,
+    generateWorktreePath: generateWorktreePathMock,
+    createWorktree: createWorktreeMock,
+    removeWorktree: removeWorktreeMock,
+  };
+});
+
+vi.mock("../../../../git.js", async () => {
+  const actual =
+    await vi.importActual<typeof import("../../../../git.js")>(
+      "../../../../git.js",
+    );
+  return {
+    ...actual,
+    getRepositoryRoot: getRepositoryRootMock,
+    deleteBranch: deleteBranchMock,
+  };
+});
+
+vi.mock("../../components/screens/WorktreeManagerScreen.js", () => {
+  return {
+    WorktreeManagerScreen: (props: any) => {
+      worktreeScreenProps.push(props);
+      return React.createElement("div", null, "WorktreeManagerScreenMock");
+    },
+  };
+});
+
+vi.mock("../../components/screens/BranchCreatorScreen.js", () => {
+  return {
+    BranchCreatorScreen: (props: any) => {
+      branchCreatorProps.push(props);
+      return React.createElement("div", null, "BranchCreatorScreenMock");
+    },
+  };
+});
+
+vi.mock("../../components/screens/BranchListScreen.js", () => {
+  return {
+    BranchListScreen: (props: any) => {
+      branchListProps.push(props);
+      return React.createElement("div", null, "BranchListScreenMock");
+    },
+  };
+});
 
 describe("App shortcuts integration", () => {
-  beforeEach(() => {
+  beforeEach(async () => {
     if (typeof globalThis.document === "undefined") {
       const window = new Window();
       globalThis.window = window as any;
@@ -86,7 +107,7 @@ describe("App shortcuts integration", () => {
     navigateToMock.mockClear();
     goBackMock.mockClear();
     resetMock.mockClear();
-    useGitDataSpy.mockImplementation(() => ({
+    useGitDataMock.mockReturnValue({
       branches: [],
       worktrees: [
         {
@@ -99,26 +120,14 @@ describe("App shortcuts integration", () => {
       error: null,
       refresh: vi.fn(),
       lastUpdated: null,
-    }));
-    useScreenStateSpy.mockImplementation(() => ({
-      currentScreen: "worktree-manager",
-      navigateTo: navigateToMock as _Mock,
-      goBack: goBackMock as _Mock,
-      reset: resetMock as _Mock,
-    }));
-    worktreeManagerScreenSpy.mockImplementation((props: any) => {
-      worktreeScreenProps.push(props);
-      return React.createElement(originalWorktreeManagerScreen, props);
-    });
-    branchCreatorScreenSpy.mockImplementation((props: any) => {
-      branchCreatorProps.push(props);
-      return React.createElement(originalBranchCreatorScreen, props);
     });
-    branchListScreenSpy.mockImplementation((props: any) => {
-      branchListProps.push(props);
-      return React.createElement(originalBranchListScreen, props);
+    useScreenStateMock.mockReturnValue({
+      currentScreen: "worktree-manager",
+      navigateTo: navigateToMock as Mock,
+      goBack: goBackMock as Mock,
+      reset: resetMock as Mock,
     });
-    getMergedPRWorktreesSpy.mockResolvedValue([
+    getMergedPRWorktreesMock.mockResolvedValue([
       {
         branch: "feature/add-new-feature",
         cleanupType: "worktree-and-branch",
@@ -152,44 +161,26 @@ describe("App shortcuts integration", () => {
         isAccessible: true,
       },
     ] as CleanupTarget[]);
-    generateWorktreePathSpy.mockResolvedValue("/worktrees/new-branch");
-    createWorktreeSpy.mockResolvedValue(undefined);
-    removeWorktreeSpy.mockResolvedValue(undefined);
-    getRepositoryRootSpy.mockResolvedValue("/repo");
-    deleteBranchSpy.mockResolvedValue(undefined);
+    generateWorktreePathMock.mockResolvedValue("/worktrees/new-branch");
+    createWorktreeMock.mockResolvedValue(undefined);
+    removeWorktreeMock.mockResolvedValue(undefined);
+    getRepositoryRootMock.mockResolvedValue("/repo");
+    deleteBranchMock.mockResolvedValue(undefined);
+    App = (await import("../../components/App.js")).App;
   });
 
   afterEach(() => {
-    useGitDataSpy.mockReset();
-    useScreenStateSpy.mockReset();
-    worktreeManagerScreenSpy.mockReset();
-    branchCreatorScreenSpy.mockReset();
-    branchListScreenSpy.mockReset();
-    getMergedPRWorktreesSpy.mockReset();
-    generateWorktreePathSpy.mockReset();
-    createWorktreeSpy.mockReset();
-    removeWorktreeSpy.mockReset();
-    getRepositoryRootSpy.mockReset();
-    deleteBranchSpy.mockReset();
-    useGitDataSpy.mockImplementation(originalUseGitData);
-    useScreenStateSpy.mockImplementation(originalUseScreenState);
-    worktreeManagerScreenSpy.mockImplementation(
-      originalWorktreeManagerScreen as any,
-    );
-    branchCreatorScreenSpy.mockImplementation(
-      originalBranchCreatorScreen as any,
-    );
-    branchListScreenSpy.mockImplementation(originalBranchListScreen as any);
-    getMergedPRWorktreesSpy.mockImplementation(
-      originalGetMergedPRWorktrees as any,
-    );
-    generateWorktreePathSpy.mockImplementation(
-      originalGenerateWorktreePath as any,
-    );
-    createWorktreeSpy.mockImplementation(originalCreateWorktree as any);
-    removeWorktreeSpy.mockImplementation(originalRemoveWorktree as any);
-    getRepositoryRootSpy.mockImplementation(originalGetRepositoryRoot as any);
-    deleteBranchSpy.mockImplementation(originalDeleteBranch as any);
+    useGitDataMock.mockReset();
+    useScreenStateMock.mockReset();
+    getMergedPRWorktreesMock.mockReset();
+    generateWorktreePathMock.mockReset();
+    createWorktreeMock.mockReset();
+    removeWorktreeMock.mockReset();
+    getRepositoryRootMock.mockReset();
+    deleteBranchMock.mockReset();
+    worktreeScreenProps.length = 0;
+    branchCreatorProps.length = 0;
+    branchListProps.length = 0;
   });
 
   it("navigates to AI tool selector when worktree is selected", () => {
@@ -209,11 +200,11 @@ describe("App shortcuts integration", () => {
     const onExit = vi.fn();
 
     // Update screen state mock to branch-creator for this test
-    useScreenStateSpy.mockReturnValue({
+    useScreenStateMock.mockReturnValue({
       currentScreen: "branch-creator",
-      navigateTo: navigateToMock as _Mock,
-      goBack: goBackMock as _Mock,
-      reset: resetMock as _Mock,
+      navigateTo: navigateToMock as Mock,
+      goBack: goBackMock as Mock,
+      reset: resetMock as Mock,
     });
 
     render(<App onExit={onExit} />);
@@ -225,7 +216,7 @@ describe("App shortcuts integration", () => {
       await onCreate("feature/new-branch");
     });
 
-    expect(createWorktreeSpy).toHaveBeenCalledWith(
+    expect(createWorktreeMock).toHaveBeenCalledWith(
       expect.objectContaining({
         branchName: "feature/new-branch",
         isNewBranch: true,
@@ -243,25 +234,25 @@ describe("App shortcuts integration", () => {
       let resolveRemoveWorktree: (() => void) | undefined;
       let resolveDeleteBranch: (() => void) | undefined;
 
-      removeWorktreeSpy.mockImplementationOnce(
+      removeWorktreeMock.mockImplementationOnce(
         () =>
           new Promise<void>((resolve) => {
             resolveRemoveWorktree = resolve;
           }),
       );
 
-      deleteBranchSpy.mockImplementationOnce(
+      deleteBranchMock.mockImplementationOnce(
         () =>
           new Promise<void>((resolve) => {
             resolveDeleteBranch = resolve;
           }),
       );
 
-      useScreenStateSpy.mockReturnValue({
+      useScreenStateMock.mockReturnValue({
         currentScreen: "branch-list",
-        navigateTo: navigateToMock as _Mock,
-        goBack: goBackMock as _Mock,
-        reset: resetMock as _Mock,
+        navigateTo: navigateToMock as Mock,
+        goBack: goBackMock as Mock,
+        reset: resetMock as Mock,
       });
 
       render(<App onExit={onExit} />);
@@ -299,11 +290,11 @@ describe("App shortcuts integration", () => {
 
       resolveDeleteBranch?.();
 
-      expect(removeWorktreeSpy).toHaveBeenCalledWith(
+      expect(removeWorktreeMock).toHaveBeenCalledWith(
         "/worktrees/feature-add-new-feature",
         true,
       );
-      expect(deleteBranchSpy).toHaveBeenCalledWith(
+      expect(deleteBranchMock).toHaveBeenCalledWith(
         "feature/add-new-feature",
         true,
       );
@@ -339,17 +330,3 @@ describe("App shortcuts integration", () => {
     }
   });
 });
-
-afterAll(() => {
-  useGitDataSpy.mockRestore();
-  useScreenStateSpy.mockRestore();
-  worktreeManagerScreenSpy.mockRestore();
-  branchCreatorScreenSpy.mockRestore();
-  branchListScreenSpy.mockRestore();
-  getMergedPRWorktreesSpy.mockRestore();
-  generateWorktreePathSpy.mockRestore();
-  createWorktreeSpy.mockRestore();
-  removeWorktreeSpy.mockRestore();
-  getRepositoryRootSpy.mockRestore();
-  deleteBranchSpy.mockRestore();
-});

package/src/cli/ui/__tests__/components/App.test.tsx

@@ -12,25 +12,59 @@ import {
 } from "vitest";
 import { act, render } from "@testing-library/react";
 import React from "react";
-import { App } from "../../components/App.js";
 import { Window } from "happy-dom";
 import type { BranchInfo } from "../../types.js";
-import * as useGitDataModule from "../../hooks/useGitData.js";
+import type { BranchListScreenProps } from "../../components/screens/BranchListScreen.js";
 
 const mockRefresh = vi.fn();
-const originalUseGitData = useGitDataModule.useGitData;
-const useGitDataSpy = vi.spyOn(useGitDataModule, "useGitData");
+let App: typeof import("../../components/App.js").App;
+const branchListProps: BranchListScreenProps[] = [];
+const useGitDataMock = vi.fn();
+
+vi.mock("../../hooks/useGitData.js", () => ({
+  useGitData: (...args: any[]) => useGitDataMock(...args),
+}));
+
+vi.mock("../../components/screens/BranchListScreen.js", () => {
+  return {
+    BranchListScreen: (props: BranchListScreenProps) => {
+      branchListProps.push(props);
+      return (
+        <div>
+          <div>gwt - Branch Selection</div>
+          <div>Local: {props.stats?.localCount ?? 0}</div>
+          <div>Remote: {props.stats?.remoteCount ?? 0}</div>
+          <div>Worktrees: {props.stats?.worktreeCount ?? 0}</div>
+          <div>Changes: {props.stats?.changesCount ?? 0}</div>
+          {props.loading && <div>Loading Git information</div>}
+          {props.error && <div>Error: {props.error.message}</div>}
+          {!props.loading && !props.error && props.branches.length === 0 && (
+            <div>No branches found</div>
+          )}
+          <ul>
+            {props.branches.map((branch) => (
+              <li
+                key={branch.name}
+              >{`${branch.icons?.join("") ?? ""} ${branch.name}`}</li>
+            ))}
+          </ul>
+        </div>
+      );
+    },
+  };
+});
 
 describe("App", () => {
-  beforeEach(() => {
+  beforeEach(async () => {
     // Setup happy-dom
     const window = new Window();
     globalThis.window = window as any;
     globalThis.document = window.document as any;
 
     vi.clearAllMocks();
-    useGitDataSpy.mockReset();
-    useGitDataSpy.mockImplementation(originalUseGitData);
+    useGitDataMock.mockReset();
+    branchListProps.length = 0;
+    App = (await import("../../components/App.js")).App;
   });
 
   const mockBranches: BranchInfo[] = [
@@ -49,61 +83,61 @@ describe("App", () => {
   ];
 
   it("should render BranchListScreen when data is loaded", () => {
-    useGitDataSpy.mockReturnValue({
+    useGitDataMock.mockImplementation(() => ({
       branches: mockBranches,
       loading: false,
       error: null,
       worktrees: [],
       refresh: mockRefresh,
-    });
+    }));
 
     const onExit = vi.fn();
-    const { getByText } = render(<App onExit={onExit} />);
-
-    // Check for BranchListScreen elements
-    expect(getByText(/gwt - Branch Selection/i)).toBeDefined();
-    expect(getByText(/main/)).toBeDefined();
-    expect(getByText(/feature\/test/)).toBeDefined();
+    render(<App onExit={onExit} />);
+
+    expect(branchListProps).not.toHaveLength(0);
+    const props = branchListProps.at(-1);
+    expect(props?.loading).toBe(false);
+    expect(props?.error).toBeNull();
+    const branchNames = props?.branches.map((b) => b.name);
+    expect(branchNames).toContain("main");
+    expect(branchNames).toContain("feature/test");
   });
 
   it("should show loading state initially", async () => {
-    useGitDataSpy.mockReturnValue({
+    useGitDataMock.mockImplementation(() => ({
       branches: [],
       loading: true,
       error: null,
       worktrees: [],
       refresh: mockRefresh,
-    });
+    }));
 
     const onExit = vi.fn();
-    const { queryByText, getByText } = render(
-      <App onExit={onExit} loadingIndicatorDelay={10} />,
-    );
+    render(<App onExit={onExit} loadingIndicatorDelay={10} />);
 
-    expect(queryByText(/Loading Git information/i)).toBeNull();
-
-    await act(async () => {
-      await new Promise((resolve) => setTimeout(resolve, 15));
-    });
-
-    expect(getByText(/Loading Git information/i)).toBeDefined();
+    expect(branchListProps).not.toHaveLength(0);
+    const props = branchListProps.at(-1);
+    expect(props?.loading).toBe(true);
+    expect(props?.loadingIndicatorDelay).toBe(10);
   });
 
   it("should show error state when Git data fails to load", () => {
     const error = new Error("Failed to fetch branches");
-    useGitDataSpy.mockReturnValue({
+    useGitDataMock.mockImplementation(() => ({
       branches: [],
       loading: false,
       error,
       worktrees: [],
       refresh: mockRefresh,
-    });
+    }));
 
     const onExit = vi.fn();
-    const { getByText } = render(<App onExit={onExit} />);
+    render(<App onExit={onExit} />);
 
-    expect(getByText(/Error:/i)).toBeDefined();
-    expect(getByText(/Failed to fetch branches/i)).toBeDefined();
+    expect(branchListProps).not.toHaveLength(0);
+    const props = branchListProps.at(-1);
+    expect(props?.error?.message).toBe("Failed to fetch branches");
+    expect(props?.loading).toBe(false);
   });
 
   it("should calculate statistics from branches", () => {
@@ -133,67 +167,71 @@ describe("App", () => {
       },
     ];
 
-    useGitDataSpy.mockReturnValue({
+    useGitDataMock.mockImplementation(() => ({
       branches: branchesWithWorktree,
       loading: false,
       error: null,
       worktrees: [],
       refresh: mockRefresh,
-    });
+    }));
 
     const onExit = vi.fn();
-    const { getByText, getAllByText } = render(<App onExit={onExit} />);
-
-    // Check for statistics
-    expect(getByText(/Local:/)).toBeDefined();
-    expect(getAllByText(/2/).length).toBeGreaterThan(0); // 2 local branches
-    expect(getByText(/Remote:/)).toBeDefined();
-    expect(getAllByText(/1/).length).toBeGreaterThan(0); // 1 remote branch + 1 worktree
-    expect(getByText(/Worktrees:/)).toBeDefined();
+    render(<App onExit={onExit} />);
+
+    expect(branchListProps).not.toHaveLength(0);
+    const props = branchListProps.at(-1);
+    expect(props?.stats.localCount).toBe(2);
+    expect(props?.stats.remoteCount).toBe(1);
+    expect(props?.stats.worktreeCount).toBe(1);
   });
 
-  it("should call onExit when branch is selected", () => {
-    useGitDataSpy.mockReturnValue({
+  it("should render branch selection without triggering exit", () => {
+    useGitDataMock.mockImplementation(() => ({
       branches: mockBranches,
       loading: false,
       error: null,
       worktrees: [],
       refresh: mockRefresh,
-    });
+    }));
 
     const onExit = vi.fn();
     const { container } = render(<App onExit={onExit} />);
 
     expect(container).toBeDefined();
+    expect(onExit).not.toHaveBeenCalled();
     // Note: Testing actual selection requires simulating user input,
     // which is covered in integration tests
   });
 
   it("should handle empty branch list", () => {
-    useGitDataSpy.mockReturnValue({
+    useGitDataMock.mockImplementation(() => ({
       branches: [],
       loading: false,
       error: null,
       worktrees: [],
       refresh: mockRefresh,
-    });
+    }));
 
     const onExit = vi.fn();
-    const { getByText } = render(<App onExit={onExit} />);
+    render(<App onExit={onExit} />);
 
-    expect(getByText(/No branches found/i)).toBeDefined();
+    expect(branchListProps).not.toHaveLength(0);
+    const props = branchListProps.at(-1);
+    expect(props?.branches).toHaveLength(0);
+    expect(props?.loading).toBe(false);
+    expect(props?.error).toBeNull();
   });
 
   it("should wrap with ErrorBoundary", () => {
     // This test verifies ErrorBoundary is present
     // Actual error catching is tested separately
-    useGitDataSpy.mockReturnValue({
+    useGitDataMock.mockImplementation(() => ({
       branches: mockBranches,
       loading: false,
       error: null,
       worktrees: [],
       refresh: mockRefresh,
-    });
+    }));
 
     const onExit = vi.fn();
     const { container } = render(<App onExit={onExit} />);
@@ -202,30 +240,32 @@ describe("App", () => {
   });
 
   it("should format branch items with icons", () => {
-    useGitDataSpy.mockReturnValue({
+    useGitDataMock.mockImplementation(() => ({
       branches: mockBranches,
       loading: false,
       error: null,
       worktrees: [],
       refresh: mockRefresh,
-    });
+    }));
 
     const onExit = vi.fn();
-    const { getByText } = render(<App onExit={onExit} />);
+    render(<App onExit={onExit} />);
 
-    // Check for branch type icon (main = ⚡)
-    expect(getByText(/⚡/)).toBeDefined();
+    expect(branchListProps).not.toHaveLength(0);
+    const props = branchListProps.at(-1);
+    const main = props?.branches.find((b: any) => b.name === "main");
+    expect(main?.icons).toContain("⚡");
   });
 
   describe("BranchActionSelectorScreen integration", () => {
     it("should show BranchActionSelectorScreen after branch selection", () => {
-      useGitDataSpy.mockReturnValue({
+      useGitDataMock.mockImplementation(() => ({
         branches: mockBranches,
         loading: false,
         error: null,
         worktrees: [],
         refresh: mockRefresh,
-      });
+      }));
 
       const onExit = vi.fn();
       const { container } = render(<App onExit={onExit} />);
@@ -235,13 +275,13 @@ describe("App", () => {
     });
 
     it('should navigate to AI tool selector when "use existing" is selected', () => {
-      useGitDataSpy.mockReturnValue({
+      useGitDataMock.mockImplementation(() => ({
         branches: mockBranches,
         loading: false,
         error: null,
         worktrees: [],
         refresh: mockRefresh,
-      });
+      }));
 
       const onExit = vi.fn();
       const { container } = render(<App onExit={onExit} />);
@@ -251,13 +291,13 @@ describe("App", () => {
     });
 
     it('should navigate to branch creator when "create new" is selected', () => {
-      useGitDataSpy.mockReturnValue({
+      useGitDataMock.mockImplementation(() => ({
         branches: mockBranches,
         loading: false,
         error: null,
         worktrees: [],
         refresh: mockRefresh,
-      });
+      }));
 
       const onExit = vi.fn();
       const { container } = render(<App onExit={onExit} />);
@@ -266,13 +306,4 @@ describe("App", () => {
       expect(container).toBeDefined();
     });
   });
-
-  afterEach(() => {
-    useGitDataSpy.mockReset();
-    useGitDataSpy.mockImplementation(originalUseGitData);
-  });
-});
-
-afterAll(() => {
-  useGitDataSpy.mockRestore();
 });