@akiojin/gwt 2.2.0 → 2.3.0

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

@@ -1,12 +1,12 @@
 /**
  * @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';
+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
@@ -14,29 +14,31 @@ import { formatBranchItems } from '../../utils/branchFormatter.js';
  */
 
 // Mock useGitData hook
-vi.mock('../../hooks/useGitData.js', () => ({
+vi.mock("../../hooks/useGitData.js", () => ({
   useGitData: vi.fn(),
 }));
 
-import { useGitData } from '../../hooks/useGitData.js';
+import { useGitData } from "../../hooks/useGitData.js";
 // const mockUseGitData = useGitData as ReturnType<typeof 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(',');
+  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(',');
+  return worktrees.map((w) => `${w.branch}-${w.path}`).join(",");
 }
 
 // Test component that uses optimized useMemo
-function TestComponent({ branches, worktrees }: { branches: BranchInfo[]; worktrees: WorktreeInfo[] }) {
+function TestComponent({
+  branches,
+  worktrees,
+}: {
+  branches: BranchInfo[];
+  worktrees: WorktreeInfo[];
+}) {
   // Count how many times formatBranchItems is called
   const formatCallCount = React.useRef(0);
 
@@ -53,17 +55,12 @@ function TestComponent({ branches, worktrees }: { branches: BranchInfo[]; worktr
       });
     }
     return formatBranchItems(branches, worktreeMap);
-  }, [
-    createBranchHash(branches),
-    createWorktreeHash(worktrees),
-  ]);
-
-  return (
-    <div data-testid="branch-count">{branchItems.length}</div>
-  );
+  }, [createBranchHash(branches), createWorktreeHash(worktrees)]);
+
+  return <div data-testid="branch-count">{branchItems.length}</div>;
 }
 
-describe('useMemo Optimization (T082-1)', () => {
+describe("useMemo Optimization (T082-1)", () => {
   beforeEach(() => {
     const window = new Window();
     globalThis.window = window as any;
@@ -71,54 +68,54 @@ describe('useMemo Optimization (T082-1)', () => {
     vi.clearAllMocks();
   });
 
-  it('should not regenerate branchItems when data content is the same', () => {
+  it("should not regenerate branchItems when data content is the same", () => {
     const mockBranches: BranchInfo[] = [
       {
-        name: 'main',
-        branchType: 'main',
-        type: 'local',
+        name: "main",
+        branchType: "main",
+        type: "local",
         isCurrent: true,
       },
       {
-        name: 'feature/test-1',
-        branchType: 'feature',
-        type: 'local',
+        name: "feature/test-1",
+        branchType: "feature",
+        type: "local",
         isCurrent: false,
       },
     ];
 
     const mockWorktrees: WorktreeInfo[] = [
       {
-        path: '/mock/worktree/feature-test-1',
-        branch: 'feature/test-1',
+        path: "/mock/worktree/feature-test-1",
+        branch: "feature/test-1",
         isAccessible: true,
       },
     ];
 
     const { rerender } = render(
-      <TestComponent branches={mockBranches} worktrees={mockWorktrees} />
+      <TestComponent branches={mockBranches} worktrees={mockWorktrees} />,
     );
 
     // Create new arrays with the same content
     const sameBranches: BranchInfo[] = [
       {
-        name: 'main',
-        branchType: 'main',
-        type: 'local',
+        name: "main",
+        branchType: "main",
+        type: "local",
         isCurrent: true,
       },
       {
-        name: 'feature/test-1',
-        branchType: 'feature',
-        type: 'local',
+        name: "feature/test-1",
+        branchType: "feature",
+        type: "local",
         isCurrent: false,
       },
     ];
 
     const sameWorktrees: WorktreeInfo[] = [
       {
-        path: '/mock/worktree/feature-test-1',
-        branch: 'feature/test-1',
+        path: "/mock/worktree/feature-test-1",
+        branch: "feature/test-1",
         isAccessible: true,
       },
     ];
@@ -129,11 +126,13 @@ describe('useMemo Optimization (T082-1)', () => {
 
     // Verify that content is the same
     expect(createBranchHash(sameBranches)).toBe(createBranchHash(mockBranches));
-    expect(createWorktreeHash(sameWorktrees)).toBe(createWorktreeHash(mockWorktrees));
+    expect(createWorktreeHash(sameWorktrees)).toBe(
+      createWorktreeHash(mockWorktrees),
+    );
 
     // Re-render with same content but different references
     rerender(
-      <TestComponent branches={sameBranches} worktrees={sameWorktrees} />
+      <TestComponent branches={sameBranches} worktrees={sameWorktrees} />,
     );
 
     // formatBranchItems should only be called once (not twice)
@@ -141,69 +140,69 @@ describe('useMemo Optimization (T082-1)', () => {
     // depends on array references, not content
   });
 
-  it('should regenerate branchItems when data content changes', () => {
+  it("should regenerate branchItems when data content changes", () => {
     const initialBranches: BranchInfo[] = [
       {
-        name: 'main',
-        branchType: 'main',
-        type: 'local',
+        name: "main",
+        branchType: "main",
+        type: "local",
         isCurrent: true,
       },
     ];
 
     const { rerender } = render(
-      <TestComponent branches={initialBranches} worktrees={[]} />
+      <TestComponent branches={initialBranches} worktrees={[]} />,
     );
 
     // Add a new branch
     const updatedBranches: BranchInfo[] = [
       ...initialBranches,
       {
-        name: 'feature/new',
-        branchType: 'feature',
-        type: 'local',
+        name: "feature/new",
+        branchType: "feature",
+        type: "local",
         isCurrent: false,
       },
     ];
 
     // Verify content changed
-    expect(createBranchHash(updatedBranches)).not.toBe(createBranchHash(initialBranches));
+    expect(createBranchHash(updatedBranches)).not.toBe(
+      createBranchHash(initialBranches),
+    );
 
     // Re-render with new content
-    rerender(
-      <TestComponent branches={updatedBranches} worktrees={[]} />
-    );
+    rerender(<TestComponent branches={updatedBranches} worktrees={[]} />);
 
     // formatBranchItems should be called twice (once for initial, once for update)
   });
 
-  it('should handle branch order changes correctly', () => {
+  it("should handle branch order changes correctly", () => {
     const branches1: BranchInfo[] = [
       {
-        name: 'main',
-        branchType: 'main',
-        type: 'local',
+        name: "main",
+        branchType: "main",
+        type: "local",
         isCurrent: true,
       },
       {
-        name: 'feature/test',
-        branchType: 'feature',
-        type: 'local',
+        name: "feature/test",
+        branchType: "feature",
+        type: "local",
         isCurrent: false,
       },
     ];
 
     const branches2: BranchInfo[] = [
       {
-        name: 'feature/test',
-        branchType: 'feature',
-        type: 'local',
+        name: "feature/test",
+        branchType: "feature",
+        type: "local",
         isCurrent: false,
       },
       {
-        name: 'main',
-        branchType: 'main',
-        type: 'local',
+        name: "main",
+        branchType: "main",
+        type: "local",
         isCurrent: true,
       },
     ];
@@ -212,21 +211,21 @@ describe('useMemo Optimization (T082-1)', () => {
     expect(createBranchHash(branches1)).not.toBe(createBranchHash(branches2));
   });
 
-  it('should detect subtle branch property changes', () => {
+  it("should detect subtle branch property changes", () => {
     const branches1: BranchInfo[] = [
       {
-        name: 'main',
-        branchType: 'main',
-        type: 'local',
+        name: "main",
+        branchType: "main",
+        type: "local",
         isCurrent: false,
       },
     ];
 
     const branches2: BranchInfo[] = [
       {
-        name: 'main',
-        branchType: 'main',
-        type: 'local',
+        name: "main",
+        branchType: "main",
+        type: "local",
         isCurrent: true, // Changed from false to true
       },
     ];