@akiojin/gwt 4.6.1 → 4.8.0

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

@@ -0,0 +1,197 @@
+/**
+ * @vitest-environment happy-dom
+ */
+import { describe, it, expect, beforeEach, vi, afterEach } from "vitest";
+import { renderHook, act, waitFor } from "@testing-library/react";
+import { Window } from "happy-dom";
+
+// モジュールをモック
+vi.mock("../../../../git.js", () => ({
+  getAllBranches: vi.fn(),
+  hasUnpushedCommitsInRepo: vi.fn(),
+  getRepositoryRoot: vi.fn(),
+  fetchAllRemotes: vi.fn(),
+  collectUpstreamMap: vi.fn(),
+  getBranchDivergenceStatuses: vi.fn(),
+  hasUncommittedChanges: vi.fn(),
+}));
+
+vi.mock("../../../../worktree.js", () => ({
+  listAdditionalWorktrees: vi.fn(),
+}));
+
+vi.mock("../../../../github.js", () => ({
+  getPullRequestByBranch: vi.fn(),
+}));
+
+vi.mock("../../../../config/index.js", () => ({
+  getLastToolUsageMap: vi.fn(),
+}));
+
+import { useGitData } from "../../hooks/useGitData.js";
+import {
+  getAllBranches,
+  getRepositoryRoot,
+  fetchAllRemotes,
+  collectUpstreamMap,
+  getBranchDivergenceStatuses,
+} from "../../../../git.js";
+import { listAdditionalWorktrees } from "../../../../worktree.js";
+import { getLastToolUsageMap } from "../../../../config/index.js";
+
+const mockGetAllBranches = getAllBranches as ReturnType<typeof vi.fn>;
+const mockGetRepositoryRoot = getRepositoryRoot as ReturnType<typeof vi.fn>;
+const mockFetchAllRemotes = fetchAllRemotes as ReturnType<typeof vi.fn>;
+const mockCollectUpstreamMap = collectUpstreamMap as ReturnType<typeof vi.fn>;
+const mockGetBranchDivergenceStatuses =
+  getBranchDivergenceStatuses as ReturnType<typeof vi.fn>;
+const mockListAdditionalWorktrees = listAdditionalWorktrees as ReturnType<
+  typeof vi.fn
+>;
+const mockGetLastToolUsageMap = getLastToolUsageMap as ReturnType<typeof vi.fn>;
+
+describe("useGitData", () => {
+  beforeEach(() => {
+    // Setup happy-dom
+    const window = new Window();
+    globalThis.window = window as unknown as typeof globalThis.window;
+    globalThis.document =
+      window.document as unknown as typeof globalThis.document;
+
+    // Reset all mocks
+    vi.clearAllMocks();
+
+    // Default mock implementations
+    mockGetRepositoryRoot.mockResolvedValue("/mock/repo");
+    mockFetchAllRemotes.mockResolvedValue(undefined);
+    mockGetAllBranches.mockResolvedValue([
+      {
+        name: "main",
+        type: "local",
+        isCurrent: true,
+        lastCommitDate: "2025-01-01",
+      },
+      {
+        name: "develop",
+        type: "local",
+        isCurrent: false,
+        lastCommitDate: "2025-01-02",
+      },
+    ]);
+    mockListAdditionalWorktrees.mockResolvedValue([]);
+    mockCollectUpstreamMap.mockResolvedValue(new Map());
+    mockGetBranchDivergenceStatuses.mockResolvedValue([]);
+    mockGetLastToolUsageMap.mockResolvedValue(new Map());
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe("キャッシュ機構", () => {
+    it("初回マウント時にGitデータを取得する", async () => {
+      const { result } = renderHook(() => useGitData());
+
+      // 初回ロード中
+      expect(result.current.loading).toBe(true);
+
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false);
+      });
+
+      // Gitデータが取得されていることを確認
+      expect(mockGetAllBranches).toHaveBeenCalledTimes(1);
+      expect(result.current.branches).toHaveLength(2);
+    });
+
+    it("refresh()を呼び出すとGitデータを再取得する", async () => {
+      const { result } = renderHook(() => useGitData());
+
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false);
+      });
+
+      // 初回ロードで1回呼ばれている
+      expect(mockGetAllBranches).toHaveBeenCalledTimes(1);
+
+      // refresh()を呼び出す
+      await act(async () => {
+        result.current.refresh();
+      });
+
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false);
+      });
+
+      // refresh後に再度呼ばれている（forceRefresh=true）
+      expect(mockGetAllBranches).toHaveBeenCalledTimes(2);
+    });
+
+    it("キャッシュ済みの場合、再マウント時にGitデータを再取得しない", async () => {
+      // 注: useGitData は内部で useRef を使ってキャッシュ状態を管理
+      // 同一コンポーネント内での再レンダリングではキャッシュが効く
+      const { result, rerender } = renderHook(() => useGitData());
+
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false);
+      });
+
+      // 初回ロードで1回呼ばれている
+      expect(mockGetAllBranches).toHaveBeenCalledTimes(1);
+
+      // 再レンダリング
+      rerender();
+
+      // キャッシュされているため追加の呼び出しはない
+      expect(mockGetAllBranches).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe("lastUpdated", () => {
+    it("データ取得成功後にlastUpdatedが更新される", async () => {
+      const { result } = renderHook(() => useGitData());
+
+      // 初期状態ではnull
+      expect(result.current.lastUpdated).toBeNull();
+
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false);
+      });
+
+      // ロード完了後にlastUpdatedが設定される
+      expect(result.current.lastUpdated).toBeInstanceOf(Date);
+    });
+  });
+
+  describe("エラーハンドリング", () => {
+    it("getAllBranchesがエラーを投げた場合、フォールバック値（空配列）が使用される", async () => {
+      // withTimeout がエラーをキャッチしてフォールバック値を返すため、
+      // エラー状態にはならず、空配列が設定される
+      mockGetAllBranches.mockRejectedValue(new Error("Git error"));
+
+      const { result } = renderHook(() => useGitData());
+
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false);
+      });
+
+      // エラーはキャッチされ、フォールバック値が使用される
+      expect(result.current.error).toBeNull();
+      expect(result.current.branches).toHaveLength(0);
+    });
+
+    it("fetchAllRemotesがエラーを投げてもローカル表示は継続される", async () => {
+      mockFetchAllRemotes.mockRejectedValue(new Error("Network error"));
+
+      const { result } = renderHook(() => useGitData());
+
+      await waitFor(() => {
+        expect(result.current.loading).toBe(false);
+      });
+
+      // リモート取得失敗でもローカルブランチは表示される
+      expect(result.current.branches).toHaveLength(2);
+      expect(result.current.error).toBeNull();
+    });
+  });
+});

package/src/cli/ui/__tests__/integration/edgeCases.test.tsx

@@ -5,6 +5,7 @@
 import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
 import { render } from "@testing-library/react";
 import React from "react";
+import { App as AppComponent } from "../../components/App.js";
 import * as BranchListScreenModule from "../../components/screens/BranchListScreen.js";
 import type { BranchListScreenProps } from "../../components/screens/BranchListScreen.js";
 import { Window } from "happy-dom";
@@ -13,12 +14,51 @@ import type { BranchInfo, BranchItem, Statistics } from "../../types.js";
 const mockRefresh = vi.fn();
 const branchListProps: BranchListScreenProps[] = [];
 const useGitDataMock = vi.fn();
-let App: typeof import("../../components/App.js").App;
+const useProfilesMock = vi.fn();
+const useToolStatusMock = vi.fn();
+const originalStdoutRows = process.stdout.rows;
+const originalStdoutColumns = process.stdout.columns;
+
+vi.mock("ink", async () => {
+  const ReactImport = await import("react");
+  const Box = ({ children }: { children?: ReactImport.ReactNode }) =>
+    ReactImport.createElement("div", null, children);
+  const Text = ({ children }: { children?: ReactImport.ReactNode }) =>
+    ReactImport.createElement("span", null, children);
+  return {
+    Box,
+    Text,
+    useApp: () => ({ exit: vi.fn() }),
+    useInput: () => {},
+    useStdout: () => ({ stdout: process.stdout, write: vi.fn() }),
+  };
+});
 
 vi.mock("../../hooks/useGitData.js", () => ({
   useGitData: (...args: unknown[]) => useGitDataMock(...args),
 }));
 
+vi.mock("../../hooks/useProfiles.js", () => ({
+  useProfiles: (...args: unknown[]) => useProfilesMock(...args),
+}));
+
+vi.mock("../../hooks/useToolStatus.js", () => ({
+  useToolStatus: (...args: unknown[]) => useToolStatusMock(...args),
+}));
+
+vi.mock("../../../utils.js", () => ({
+  getPackageVersion: vi.fn(async () => "0.0.0-test"),
+}));
+
+vi.mock("../../../git.js", () => ({
+  getRepositoryRoot: vi.fn(async () => "/repo"),
+  deleteBranch: vi.fn(async () => undefined),
+}));
+
+vi.mock("../../../config/index.js", () => ({
+  loadSession: vi.fn(async () => null),
+}));
+
 vi.mock("../../components/screens/BranchListScreen.js", () => ({
   BranchListScreen: (props: BranchListScreenProps) => {
     branchListProps.push(props);
@@ -42,7 +82,7 @@ vi.mock("../../components/screens/BranchListScreen.js", () => ({
 }));
 
 describe("Edge Cases Integration Tests", () => {
-  beforeEach(async () => {
+  beforeEach(() => {
     // Setup happy-dom
     const window = new Window();
     globalThis.window = window as unknown as typeof globalThis.window;
@@ -52,8 +92,44 @@ describe("Edge Cases Integration Tests", () => {
     // Reset mocks
     vi.clearAllMocks();
     useGitDataMock.mockReset();
+    useProfilesMock.mockReset();
+    useToolStatusMock.mockReset();
     branchListProps.length = 0;
-    App = (await import("../../components/App.js")).App;
+    useGitDataMock.mockReturnValue({
+      branches: [],
+      worktrees: [],
+      loading: false,
+      error: null,
+      refresh: mockRefresh,
+      lastUpdated: null,
+    });
+
+    useProfilesMock.mockReturnValue({
+      profiles: null,
+      loading: false,
+      error: null,
+      activeProfileName: null,
+      activeProfile: null,
+      refresh: vi.fn(),
+      setActiveProfile: vi.fn(),
+      createProfile: vi.fn(),
+      updateProfile: vi.fn(),
+      deleteProfile: vi.fn(),
+      updateEnvVar: vi.fn(),
+      deleteEnvVar: vi.fn(),
+    });
+
+    useToolStatusMock.mockReturnValue({
+      tools: [],
+      loading: false,
+      error: null,
+      refresh: vi.fn(),
+    });
+  });
+
+  afterEach(() => {
+    process.stdout.rows = originalStdoutRows;
+    process.stdout.columns = originalStdoutColumns;
   });
 
   /**
@@ -218,7 +294,7 @@ describe("Edge Cases Integration Tests", () => {
    * testing unreliable in testing-library. The error is thrown but not caught
    * by the test framework correctly.
    */
-  it.skip("[T093] should catch errors in App component", async () => {
+  it.skip("[T093] should catch errors in App component", () => {
     // Mock useGitData to throw an error after initial render
     let callCount = 0;
     useGitDataMock.mockImplementation(() => {
@@ -237,7 +313,7 @@ describe("Edge Cases Integration Tests", () => {
     });
 
     const onExit = vi.fn();
-    const { container } = render(<App onExit={onExit} />);
+    const { container } = render(<AppComponent onExit={onExit} />);
 
     // Initial render should work
     expect(container).toBeDefined();
@@ -255,7 +331,7 @@ describe("Edge Cases Integration Tests", () => {
     });
 
     const onExit = vi.fn();
-    const { getByText } = render(<App onExit={onExit} />);
+    const { getByText } = render(<AppComponent onExit={onExit} />);
 
     expect(branchListProps).not.toHaveLength(0);
     expect(branchListProps.at(-1)?.error).toBe(testError);
@@ -275,7 +351,7 @@ describe("Edge Cases Integration Tests", () => {
     });
 
     const onExit = vi.fn();
-    const { container } = render(<App onExit={onExit} />);
+    const { container } = render(<AppComponent onExit={onExit} />);
 
     // Should render without error even with no branches
     expect(container).toBeDefined();
@@ -307,7 +383,7 @@ describe("Edge Cases Integration Tests", () => {
     });
 
     const onExit = vi.fn();
-    const { container } = render(<App onExit={onExit} />);
+    const { container } = render(<AppComponent onExit={onExit} />);
 
     expect(container).toBeDefined();
   });
@@ -357,9 +433,4 @@ describe("Edge Cases Integration Tests", () => {
 
     process.stdout.rows = originalRows;
   });
-
-  afterEach(() => {
-    useGitDataMock.mockReset();
-    branchListProps.length = 0;
-  });
 });

package/src/cli/ui/__tests__/integration/navigation.test.tsx

@@ -1,15 +1,7 @@
 /**
  * @vitest-environment happy-dom
  */
-import {
-  describe,
-  it,
-  expect,
-  beforeEach,
-  afterEach,
-  afterAll,
-  vi,
-} from "vitest";
+import { describe, it, expect, beforeEach, afterAll, vi } from "vitest";
 import type { Mock } from "vitest";
 import { render, waitFor } from "@testing-library/react";
 import { act } from "react-dom/test-utils";
@@ -17,11 +9,12 @@ import React from "react";
 import { App } from "../../components/App.js";
 import { Window } from "happy-dom";
 import type { BranchInfo, BranchItem } from "../../types.js";
-import * as BranchListScreenModule from "../../components/screens/BranchListScreen.js";
 import type { BranchListScreenProps } from "../../components/screens/BranchListScreen.js";
-import * as BranchActionSelectorScreenModule from "../../screens/BranchActionSelectorScreen.js";
 import type { BranchActionSelectorScreenProps } from "../../screens/BranchActionSelectorScreen.js";
 
+const branchListProps: BranchListScreenProps[] = [];
+const branchActionProps: BranchActionSelectorScreenProps[] = [];
+
 vi.mock("../../../../git.ts", () => ({
   __esModule: true,
   getAllBranches: vi.fn(),
@@ -32,6 +25,45 @@ vi.mock("../../../../git.ts", () => ({
   getBranchDivergenceStatuses: vi.fn(async () => []),
 }));
 
+vi.mock("../../../../config/index.js", () => ({
+  loadSession: vi.fn(),
+  getLastToolUsageMap: vi.fn(),
+}));
+
+vi.mock(
+  "../../components/screens/BranchListScreen.js",
+  async (importOriginal) => {
+    const actual =
+      await importOriginal<
+        typeof import("../../components/screens/BranchListScreen.js")
+      >();
+    return {
+      ...actual,
+      BranchListScreen: (props: BranchListScreenProps) => {
+        branchListProps.push(props);
+        return React.createElement(actual.BranchListScreen, props);
+      },
+    };
+  },
+);
+
+vi.mock(
+  "../../screens/BranchActionSelectorScreen.js",
+  async (importOriginal) => {
+    const actual =
+      await importOriginal<
+        typeof import("../../screens/BranchActionSelectorScreen.js")
+      >();
+    return {
+      ...actual,
+      BranchActionSelectorScreen: (props: BranchActionSelectorScreenProps) => {
+        branchActionProps.push(props);
+        return React.createElement(actual.BranchActionSelectorScreen, props);
+      },
+    };
+  },
+);
+
 const { mockIsProtectedBranchName, mockSwitchToProtectedBranch } = vi.hoisted(
   () => ({
     mockIsProtectedBranchName: vi.fn(() => false),
@@ -74,6 +106,7 @@ import {
   getMergedPRWorktrees,
   removeWorktree,
 } from "../../../../worktree.ts";
+import { loadSession, getLastToolUsageMap } from "../../../../config/index.js";
 
 const mockedGetAllBranches = getAllBranches as Mock;
 const mockedGetRepositoryRoot = getRepositoryRoot as Mock;
@@ -86,9 +119,8 @@ const mockedGetMergedPRWorktrees = getMergedPRWorktrees as Mock;
 const mockedRemoveWorktree = removeWorktree as Mock;
 const mockedIsProtectedBranchName = mockIsProtectedBranchName as Mock;
 const mockedSwitchToProtectedBranch = mockSwitchToProtectedBranch as Mock;
-const originalBranchListScreen = BranchListScreenModule.BranchListScreen;
-const originalBranchActionSelectorScreen =
-  BranchActionSelectorScreenModule.BranchActionSelectorScreen;
+const mockedLoadSession = loadSession as Mock;
+const mockedGetLastToolUsageMap = getLastToolUsageMap as Mock;
 
 describe("Navigation Integration Tests", () => {
   beforeEach(() => {
@@ -110,8 +142,15 @@ describe("Navigation Integration Tests", () => {
     mockedRemoveWorktree.mockReset();
     mockedIsProtectedBranchName.mockReset();
     mockedSwitchToProtectedBranch.mockReset();
+    mockedLoadSession.mockReset();
+    mockedGetLastToolUsageMap.mockReset();
+    branchListProps.length = 0;
+    branchActionProps.length = 0;
+    aiToolScreenProps.length = 0;
     mockedGetRepositoryRoot.mockResolvedValue("/repo");
     mockedSwitchToProtectedBranch.mockResolvedValue("local");
+    mockedLoadSession.mockResolvedValue({ history: [] });
+    mockedGetLastToolUsageMap.mockResolvedValue(new Map());
   });
 
   const mockBranches: BranchInfo[] = [
@@ -248,11 +287,6 @@ describe("Navigation Integration Tests", () => {
 });
 
 describe("Protected Branch Navigation (T103)", () => {
-  const branchListProps: BranchListScreenProps[] = [];
-  const branchActionProps: BranchActionSelectorScreenProps[] = [];
-  let branchListSpy: ReturnType<typeof vi.spyOn>;
-  let branchActionSpy: ReturnType<typeof vi.spyOn>;
-
   const baseBranches: BranchInfo[] = [
     {
       name: "main",
@@ -284,33 +318,19 @@ describe("Protected Branch Navigation (T103)", () => {
     mockedRemoveWorktree.mockReset();
     mockedIsProtectedBranchName.mockReset();
     mockedSwitchToProtectedBranch.mockReset();
+    mockedLoadSession.mockReset();
+    mockedGetLastToolUsageMap.mockReset();
     mockedGetRepositoryRoot.mockResolvedValue("/repo");
     branchListProps.length = 0;
     branchActionProps.length = 0;
     aiToolScreenProps.length = 0;
-    branchListSpy = vi
-      .spyOn(BranchListScreenModule, "BranchListScreen")
-      .mockImplementation((props: BranchListScreenProps) => {
-        branchListProps.push(props);
-        return React.createElement(originalBranchListScreen, props);
-      });
-    branchActionSpy = vi
-      .spyOn(BranchActionSelectorScreenModule, "BranchActionSelectorScreen")
-      .mockImplementation((props: BranchActionSelectorScreenProps) => {
-        branchActionProps.push(props);
-        return React.createElement(originalBranchActionSelectorScreen, props);
-      });
-
     mockedIsProtectedBranchName.mockImplementation((name: string) =>
       ["main", "develop", "origin/main", "origin/develop"].includes(name),
     );
     mockedSwitchToProtectedBranch.mockResolvedValue("local");
     mockedGetRepositoryRoot.mockResolvedValue("/repo");
-  });
-
-  afterEach(() => {
-    branchListSpy.mockRestore();
-    branchActionSpy.mockRestore();
+    mockedLoadSession.mockResolvedValue({ history: [] });
+    mockedGetLastToolUsageMap.mockResolvedValue(new Map());
   });
 
   it("prefills AI tool selector with last used tool for the branch", async () => {

package/src/cli/ui/__tests__/utils/branchFormatter.test.ts

@@ -848,5 +848,110 @@ describe("branchFormatter", () => {
       expect(results[1].name).toBe("hotfix/urgent");
       expect(results[2].name).toBe("release/v1.0");
     });
+
+    it("should sort by latest activity time (max of git commit and tool usage)", () => {
+      const branches: BranchInfo[] = [
+        {
+          name: "feature/git-newer",
+          type: "local",
+          branchType: "feature",
+          isCurrent: false,
+          latestCommitTimestamp: 1_800_000_000, // git commit is newer
+          lastToolUsage: {
+            branch: "feature/git-newer",
+            worktreePath: "/tmp/wt1",
+            toolId: "claude-code",
+            toolLabel: "Claude",
+            timestamp: 1_700_000_000_000, // 1_700_000_000 seconds (older)
+          },
+        },
+        {
+          name: "feature/tool-newer",
+          type: "local",
+          branchType: "feature",
+          isCurrent: false,
+          latestCommitTimestamp: 1_700_000_000, // git commit is older
+          lastToolUsage: {
+            branch: "feature/tool-newer",
+            worktreePath: "/tmp/wt2",
+            toolId: "claude-code",
+            toolLabel: "Claude",
+            timestamp: 1_800_000_000_000, // 1_800_000_000 seconds (newer)
+          },
+        },
+      ];
+
+      const results = formatBranchItems(branches);
+
+      // Both have same latest activity time (1_800_000_000), so alphabetical
+      // feature/git-newer: max(1_800_000_000, 1_700_000_000) = 1_800_000_000
+      // feature/tool-newer: max(1_700_000_000, 1_800_000_000) = 1_800_000_000
+      expect(results[0].name).toBe("feature/git-newer");
+      expect(results[1].name).toBe("feature/tool-newer");
+    });
+
+    it("should prioritize branch with tool usage over branch with only git commit when tool is newer", () => {
+      const branches: BranchInfo[] = [
+        {
+          name: "feature/git-only",
+          type: "local",
+          branchType: "feature",
+          isCurrent: false,
+          latestCommitTimestamp: 1_700_000_000,
+        },
+        {
+          name: "feature/with-tool",
+          type: "local",
+          branchType: "feature",
+          isCurrent: false,
+          latestCommitTimestamp: 1_600_000_000,
+          lastToolUsage: {
+            branch: "feature/with-tool",
+            worktreePath: "/tmp/wt",
+            toolId: "claude-code",
+            toolLabel: "Claude",
+            timestamp: 1_800_000_000_000, // 1_800_000_000 seconds (newest)
+          },
+        },
+      ];
+
+      const results = formatBranchItems(branches);
+
+      // feature/with-tool has newer activity (tool usage at 1_800_000_000)
+      expect(results[0].name).toBe("feature/with-tool");
+      expect(results[1].name).toBe("feature/git-only");
+    });
+
+    it("should prioritize branch with newer git commit over branch with older tool usage", () => {
+      const branches: BranchInfo[] = [
+        {
+          name: "feature/old-tool",
+          type: "local",
+          branchType: "feature",
+          isCurrent: false,
+          latestCommitTimestamp: 1_600_000_000,
+          lastToolUsage: {
+            branch: "feature/old-tool",
+            worktreePath: "/tmp/wt",
+            toolId: "claude-code",
+            toolLabel: "Claude",
+            timestamp: 1_650_000_000_000, // 1_650_000_000 seconds
+          },
+        },
+        {
+          name: "feature/new-git",
+          type: "local",
+          branchType: "feature",
+          isCurrent: false,
+          latestCommitTimestamp: 1_800_000_000, // newest
+        },
+      ];
+
+      const results = formatBranchItems(branches);
+
+      // feature/new-git has newer activity (git commit at 1_800_000_000)
+      expect(results[0].name).toBe("feature/new-git");
+      expect(results[1].name).toBe("feature/old-tool");
+    });
   });
 });