@akiojin/gwt 2.0.0

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

@@ -0,0 +1,214 @@
+/**
+ * @vitest-environment happy-dom
+ * Acceptance tests for User Story 2: Sub-screen Navigation
+ */
+import { describe, it, expect, beforeEach, afterAll, vi } from 'vitest';
+import type { Mock } from 'vitest';
+import { render, waitFor } 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';
+
+// Mock git.ts and worktree.ts
+vi.mock('../../../../git.ts', () => ({
+  __esModule: true,
+  getAllBranches: vi.fn(),
+  getRepositoryRoot: vi.fn(async () => '/repo'),
+  deleteBranch: vi.fn(async () => undefined),
+}));
+
+const { acceptanceIsProtectedBranchName, acceptanceSwitchToProtectedBranch } = vi.hoisted(() => ({
+  acceptanceIsProtectedBranchName: vi.fn(() => false),
+  acceptanceSwitchToProtectedBranch: vi.fn(async () => 'none' as const),
+}));
+
+vi.mock('../../../../worktree.ts', () => ({
+  __esModule: true,
+  listAdditionalWorktrees: vi.fn(),
+  createWorktree: vi.fn(async () => undefined),
+  generateWorktreePath: vi.fn(async () => '/repo/.git/worktree/test'),
+  getMergedPRWorktrees: vi.fn(async () => []),
+  removeWorktree: vi.fn(async () => undefined),
+  isProtectedBranchName: acceptanceIsProtectedBranchName,
+  switchToProtectedBranch: acceptanceSwitchToProtectedBranch,
+}));
+
+import { getAllBranches, getRepositoryRoot, deleteBranch } from '../../../../git.ts';
+import {
+  listAdditionalWorktrees,
+  createWorktree,
+  generateWorktreePath,
+  getMergedPRWorktrees,
+  removeWorktree,
+} from '../../../../worktree.ts';
+
+const mockedGetAllBranches = getAllBranches as Mock;
+const mockedGetRepositoryRoot = getRepositoryRoot as Mock;
+const mockedDeleteBranch = deleteBranch as Mock;
+const mockedListAdditionalWorktrees = listAdditionalWorktrees as Mock;
+const mockedCreateWorktree = createWorktree as Mock;
+const mockedGenerateWorktreePath = generateWorktreePath as Mock;
+const mockedGetMergedPRWorktrees = getMergedPRWorktrees as Mock;
+const mockedRemoveWorktree = removeWorktree as Mock;
+const mockedIsProtectedBranchName = acceptanceIsProtectedBranchName as Mock;
+const mockedSwitchToProtectedBranch = acceptanceSwitchToProtectedBranch as Mock;
+
+describe('Acceptance: Navigation (User Story 2)', () => {
+  beforeEach(() => {
+    // Setup happy-dom
+    const window = new Window();
+    globalThis.window = window as any;
+    globalThis.document = window.document as any;
+
+    // Reset mocks
+    mockedGetAllBranches.mockReset();
+    mockedListAdditionalWorktrees.mockReset();
+    mockedGetRepositoryRoot.mockReset();
+    mockedDeleteBranch.mockReset();
+    mockedCreateWorktree.mockReset();
+    mockedGenerateWorktreePath.mockReset();
+    mockedGetMergedPRWorktrees.mockReset();
+    mockedRemoveWorktree.mockReset();
+    mockedIsProtectedBranchName.mockReset();
+    mockedSwitchToProtectedBranch.mockReset();
+    mockedGetRepositoryRoot.mockResolvedValue('/repo');
+    mockedSwitchToProtectedBranch.mockResolvedValue('none');
+  });
+
+  const mockBranches: BranchInfo[] = [
+    {
+      name: 'main',
+      type: 'local',
+      branchType: 'main',
+      isCurrent: true,
+    },
+    {
+      name: 'feature/test',
+      type: 'local',
+      branchType: 'feature',
+      isCurrent: false,
+    },
+  ];
+
+  /**
+   * T074: Acceptance Scenario 1
+   * nキーで新規ブランチ作成画面に遷移
+   */
+  it('[AC1] should navigate to branch creator on n key', async () => {
+    (getAllBranches as ReturnType<typeof vi.fn>).mockResolvedValue(mockBranches);
+    (listAdditionalWorktrees as ReturnType<typeof vi.fn>).mockResolvedValue([]);
+
+    const onExit = vi.fn();
+    const { getByText, container } = render(<App onExit={onExit} />);
+
+    await waitFor(() => {
+      expect(getByText(/gwt - Branch Selection/i)).toBeDefined();
+    });
+
+    // Verify n key action is available in footer
+    const nKeyElements = container.querySelectorAll('*');
+    let hasNKey = false;
+    nKeyElements.forEach((el) => {
+      if (el.textContent?.toLowerCase().includes('new branch')) {
+        hasNKey = true;
+      }
+    });
+
+    expect(hasNKey || container.textContent?.toLowerCase().includes('n')).toBe(true);
+  });
+
+  /**
+   * T075: Acceptance Scenario 2
+   * メイン画面にはqキーが存在しない（終了はCtrl+Cのみ）
+   */
+  it('[AC2] should not have q key on main screen', async () => {
+    (getAllBranches as ReturnType<typeof vi.fn>).mockResolvedValue(mockBranches);
+    (listAdditionalWorktrees as ReturnType<typeof vi.fn>).mockResolvedValue([]);
+
+    const onExit = vi.fn();
+    const { container } = render(<App onExit={onExit} />);
+
+    await waitFor(() => {
+      expect(container).toBeDefined();
+    });
+
+    // Verify q key is NOT in the footer (main screen uses Ctrl+C for exit)
+    const footerText = container.textContent || '';
+    // Main screen should not have 'q' for quit, but should have other keys
+    expect(footerText.toLowerCase()).not.toMatch(/\[q\]/);
+    expect(footerText.toLowerCase()).toContain('enter');
+  });
+
+  /**
+   * T076: Acceptance Scenario 3
+   * Worktree管理でアクション実行後に適切に遷移
+   */
+  it('[AC3] should handle worktree management navigation', async () => {
+    (getAllBranches as ReturnType<typeof vi.fn>).mockResolvedValue(mockBranches);
+    (listAdditionalWorktrees as ReturnType<typeof vi.fn>).mockResolvedValue([
+      {
+        branch: 'feature/test',
+        path: '/path/to/worktree',
+        head: 'abc123',
+        isAccessible: true,
+      },
+    ]);
+
+    const onExit = vi.fn();
+    const { getByText, container } = render(<App onExit={onExit} />);
+
+    await waitFor(() => {
+      expect(getByText(/gwt - Branch Selection/i)).toBeDefined();
+    });
+
+    // Verify m key action is available for worktree management
+    const mKeyElements = container.querySelectorAll('*');
+    let hasMKey = false;
+    mKeyElements.forEach((el) => {
+      if (el.textContent?.toLowerCase().includes('manage worktrees')) {
+        hasMKey = true;
+      }
+    });
+
+    expect(hasMKey || container.textContent?.toLowerCase().includes('m')).toBe(true);
+  });
+
+  it('[Integration] should support all navigation keys', async () => {
+    (getAllBranches as ReturnType<typeof vi.fn>).mockResolvedValue(mockBranches);
+    (listAdditionalWorktrees as ReturnType<typeof vi.fn>).mockResolvedValue([]);
+
+    const onExit = vi.fn();
+    const { getByText, getAllByText } = render(<App onExit={onExit} />);
+
+    await waitFor(() => {
+      expect(getByText(/gwt - Branch Selection/i)).toBeDefined();
+    });
+
+    // Verify navigation keys are available (main screen doesn't have q key)
+    const enterKeys = getAllByText(/enter/i);
+
+    expect(enterKeys.length).toBeGreaterThan(0);
+  });
+
+  it('[Integration] should display correct footer actions', async () => {
+    (getAllBranches as ReturnType<typeof vi.fn>).mockResolvedValue(mockBranches);
+    (listAdditionalWorktrees as ReturnType<typeof vi.fn>).mockResolvedValue([]);
+
+    const onExit = vi.fn();
+    const { container } = render(<App onExit={onExit} />);
+
+    await waitFor(() => {
+      expect(container).toBeDefined();
+    });
+
+    // Verify footer has multiple action keys (main screen doesn't have q key)
+    const footerText = container.textContent || '';
+    expect(footerText.toLowerCase()).toContain('enter');
+    expect(footerText.toLowerCase()).toContain('m'); // Manage worktrees
+  });
+});
+
+afterAll(() => {
+  vi.restoreAllMocks();
+});

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

@@ -0,0 +1,219 @@
+/**
+ * @vitest-environment happy-dom
+ * Acceptance tests for User Story 3: Realtime Statistics Update
+ */
+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('Acceptance: Realtime Update (User Story 3)', () => {
+  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();
+  });
+
+  /**
+   * T085: Acceptance Scenario 1
+   * 別ターミナルでGit操作後、数秒以内に統計情報が更新される
+   */
+  it('[AC1] should update statistics within seconds after Git operations', async () => {
+    // Simulate initial state
+    const initialBranches: BranchInfo[] = [
+      { name: 'main', type: 'local', branchType: 'main', isCurrent: true },
+      { name: 'feature/a', type: 'local', branchType: 'feature', isCurrent: false },
+    ];
+
+    let callCount = 0;
+    (getAllBranches as ReturnType<typeof vi.fn>).mockImplementation(async () => {
+      callCount++;
+      if (callCount === 1) {
+        return initialBranches;
+      }
+      // Simulate Git operation: new branch created
+      return [
+        ...initialBranches,
+        { name: 'feature/b', type: 'local', branchType: 'feature', isCurrent: false },
+      ];
+    });
+    (listAdditionalWorktrees as ReturnType<typeof vi.fn>).mockResolvedValue([]);
+
+    // Enable auto-refresh with 1 second interval
+    const { result } = renderHook(() =>
+      useGitData({ enableAutoRefresh: true, refreshInterval: 1000 })
+    );
+
+    // Wait for initial load
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+    });
+
+    expect(result.current.branches).toHaveLength(2);
+    const initialLastUpdated = result.current.lastUpdated;
+
+    // Simulate Git operation happening in another terminal
+    // Wait for auto-refresh (slightly more than 1 second)
+    await new Promise((resolve) => setTimeout(resolve, 1100));
+
+    // Statistics should be updated
+    await waitFor(
+      () => {
+        expect(result.current.branches).toHaveLength(3);
+      },
+      { timeout: 2000 }
+    );
+
+    expect(result.current.branches[2].name).toBe('feature/b');
+    expect(result.current.lastUpdated!.getTime()).toBeGreaterThan(
+      initialLastUpdated!.getTime()
+    );
+  });
+
+  /**
+   * T086: Acceptance Scenario 2
+   * Worktree作成/削除後、統計情報が即座に更新される
+   */
+  it('[AC2] should update statistics immediately after worktree operations', async () => {
+    const mockBranches: BranchInfo[] = [
+      { name: 'main', type: 'local', branchType: 'main', isCurrent: true },
+      { name: 'feature/test', type: 'local', branchType: 'feature', isCurrent: false },
+    ];
+
+    let worktreeCallCount = 0;
+    (getAllBranches as ReturnType<typeof vi.fn>).mockResolvedValue(mockBranches);
+    (listAdditionalWorktrees as ReturnType<typeof vi.fn>).mockImplementation(async () => {
+      worktreeCallCount++;
+      if (worktreeCallCount === 1) {
+        return [];
+      }
+      // Simulate worktree creation
+      return [
+        {
+          branch: 'feature/test',
+          path: '/path/to/worktree',
+          head: 'abc123',
+          isAccessible: true,
+        },
+      ];
+    });
+
+    // Enable auto-refresh with 500ms interval
+    const { result } = renderHook(() =>
+      useGitData({ enableAutoRefresh: true, refreshInterval: 500 })
+    );
+
+    // Wait for initial load
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+    });
+
+    expect(result.current.worktrees).toHaveLength(0);
+
+    // Simulate worktree creation in another terminal
+    // Wait for auto-refresh (slightly more than 500ms)
+    await new Promise((resolve) => setTimeout(resolve, 600));
+
+    // Worktree statistics should be updated
+    await waitFor(
+      () => {
+        expect(result.current.worktrees).toHaveLength(1);
+      },
+      { timeout: 1000 }
+    );
+
+    expect(result.current.worktrees[0].branch).toBe('feature/test');
+    expect(result.current.worktrees[0].path).toBe('/path/to/worktree');
+  });
+
+  /**
+   * Additional: Verify lastUpdated display behavior
+   */
+  it('[AC3] should display lastUpdated timestamp after each 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({ enableAutoRefresh: true, refreshInterval: 200 })
+    );
+
+    // Wait for initial load
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+    });
+
+    const firstTimestamp = result.current.lastUpdated;
+    expect(firstTimestamp).toBeInstanceOf(Date);
+
+    // Wait for auto-refresh
+    await new Promise((resolve) => setTimeout(resolve, 250));
+
+    await waitFor(() => {
+      expect(result.current.lastUpdated!.getTime()).toBeGreaterThan(firstTimestamp!.getTime());
+    });
+
+    const secondTimestamp = result.current.lastUpdated;
+    expect(secondTimestamp).toBeInstanceOf(Date);
+
+    // Verify timestamps are different
+    expect(secondTimestamp!.getTime()).toBeGreaterThan(firstTimestamp!.getTime());
+  });
+
+  /**
+   * Additional: Verify manual refresh updates lastUpdated
+   */
+  it('[AC4] should update lastUpdated on 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({ enableAutoRefresh: false }));
+
+    // Wait for initial load
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+    });
+
+    const firstTimestamp = result.current.lastUpdated;
+    expect(firstTimestamp).toBeInstanceOf(Date);
+
+    // Wait to ensure timestamp difference
+    await new Promise((resolve) => setTimeout(resolve, 50));
+
+    // Manual refresh
+    result.current.refresh();
+
+    await waitFor(() => {
+      expect(result.current.loading).toBe(false);
+    });
+
+    const secondTimestamp = result.current.lastUpdated;
+    expect(secondTimestamp).toBeInstanceOf(Date);
+    expect(secondTimestamp!.getTime()).toBeGreaterThan(firstTimestamp!.getTime());
+  });
+});

package/src/cli/ui/__tests__/components/App.protected-branch.test.tsx

@@ -0,0 +1,183 @@
+/**
+ * @vitest-environment happy-dom
+ */
+import { describe, it, expect, beforeEach, afterEach, afterAll, vi } from 'vitest';
+import { act, render } from '@testing-library/react';
+import React from 'react';
+import { Window } from 'happy-dom';
+import { App } from '../../components/App.js';
+import type { BranchInfo, BranchItem } from '../../types.js';
+import * as useGitDataModule from '../../hooks/useGitData.js';
+import * as useScreenStateModule from '../../hooks/useScreenState.js';
+import * as BranchListScreenModule from '../../components/screens/BranchListScreen.js';
+import * as BranchActionSelectorScreenModule from '../../screens/BranchActionSelectorScreen.js';
+import * as worktreeModule from '../../../../worktree.ts';
+import * as gitModule from '../../../../git.ts';
+import type { ScreenType } from '../../types.js';
+
+const navigateToMock = vi.fn();
+const goBackMock = vi.fn();
+const resetMock = vi.fn();
+
+const originalUseGitData = useGitDataModule.useGitData;
+const originalUseScreenState = useScreenStateModule.useScreenState;
+const originalBranchListScreen = BranchListScreenModule.BranchListScreen;
+const originalBranchActionSelector = BranchActionSelectorScreenModule.BranchActionSelectorScreen;
+const originalGetRepositoryRoot = gitModule.getRepositoryRoot;
+
+const useGitDataSpy = vi.spyOn(useGitDataModule, 'useGitData');
+const useScreenStateSpy = vi.spyOn(useScreenStateModule, 'useScreenState');
+const branchListScreenSpy = vi.spyOn(BranchListScreenModule, 'BranchListScreen');
+const branchActionSelectorSpy = vi.spyOn(BranchActionSelectorScreenModule, 'BranchActionSelectorScreen');
+const switchToProtectedBranchSpy = vi.spyOn(worktreeModule, 'switchToProtectedBranch');
+const getRepositoryRootSpy = vi.spyOn(gitModule, 'getRepositoryRoot');
+
+const branchListProps: any[] = [];
+const branchActionProps: any[] = [];
+const aiToolProps: any[] = [];
+let currentScreenState: ScreenType;
+
+vi.mock('../../components/screens/AIToolSelectorScreen.js', () => {
+  return {
+    AIToolSelectorScreen: (props: unknown) => {
+      aiToolProps.push(props);
+      return React.createElement('div');
+    },
+  };
+});
+
+describe('App protected branch handling', () => {
+  beforeEach(() => {
+    const window = new Window();
+    globalThis.window = window as any;
+    globalThis.document = window.document as any;
+
+    currentScreenState = 'branch-list';
+    navigateToMock.mockReset();
+    goBackMock.mockReset();
+    resetMock.mockReset();
+    branchListProps.length = 0;
+    branchActionProps.length = 0;
+    aiToolProps.length = 0;
+
+    useGitDataSpy.mockReset();
+    switchToProtectedBranchSpy.mockReset();
+    getRepositoryRootSpy.mockReset();
+
+    useScreenStateSpy.mockImplementation(() => ({
+      currentScreen: currentScreenState,
+      navigateTo: (screen: ScreenType) => {
+        navigateToMock(screen);
+        currentScreenState = screen;
+      },
+      goBack: goBackMock,
+      reset: () => {
+        resetMock();
+        currentScreenState = 'branch-list';
+      },
+    }));
+
+    branchListScreenSpy.mockImplementation((props: any) => {
+      branchListProps.push(props);
+      return React.createElement(originalBranchListScreen, props);
+    });
+    branchActionSelectorSpy.mockImplementation((props: any) => {
+      branchActionProps.push(props);
+      return React.createElement(originalBranchActionSelector, props);
+    });
+    switchToProtectedBranchSpy.mockResolvedValue('local');
+    getRepositoryRootSpy.mockResolvedValue('/repo');
+  });
+
+  afterEach(() => {
+    useGitDataSpy.mockReset();
+    useGitDataSpy.mockImplementation(originalUseGitData);
+    useScreenStateSpy.mockReset();
+    useScreenStateSpy.mockImplementation(originalUseScreenState);
+    branchListScreenSpy.mockImplementation(originalBranchListScreen as any);
+    branchActionSelectorSpy.mockImplementation(originalBranchActionSelector as any);
+    switchToProtectedBranchSpy.mockReset();
+    getRepositoryRootSpy.mockReset();
+    branchActionProps.length = 0;
+  });
+
+  afterAll(() => {
+    useGitDataSpy.mockRestore();
+    useScreenStateSpy.mockRestore();
+    branchListScreenSpy.mockRestore();
+    branchActionSelectorSpy.mockRestore();
+    switchToProtectedBranchSpy.mockRestore();
+    getRepositoryRootSpy.mockRestore();
+  });
+
+  it('shows protected branch warning and switches root without launching AI tool', async () => {
+    const branches: BranchInfo[] = [
+      {
+        name: 'main',
+        type: 'local',
+        branchType: 'main',
+        isCurrent: false,
+      },
+      {
+        name: 'feature/example',
+        type: 'local',
+        branchType: 'feature',
+        isCurrent: true,
+      },
+    ];
+
+    useGitDataSpy.mockImplementation(() => ({
+      branches,
+      worktrees: [],
+      loading: false,
+      error: null,
+      refresh: vi.fn(),
+      lastUpdated: null,
+    }));
+
+    render(<App onExit={vi.fn()} />);
+
+    expect(branchListProps).not.toHaveLength(0);
+    const latestProps = branchListProps.at(-1);
+    expect(latestProps).toBeDefined();
+    if (!latestProps) {
+      throw new Error('BranchListScreen props missing');
+    }
+
+    const protectedBranch = (latestProps.branches as BranchItem[]).find(
+      (item) => item.name === 'main'
+    );
+    expect(protectedBranch).toBeDefined();
+    if (!protectedBranch) {
+      throw new Error('Protected branch item not found');
+    }
+
+    await act(async () => {
+      latestProps.onSelect(protectedBranch);
+      await Promise.resolve();
+    });
+
+    expect(navigateToMock).toHaveBeenCalledWith('branch-action-selector');
+    expect(branchActionProps).not.toHaveLength(0);
+    const actionProps = branchActionProps.at(-1);
+    expect(actionProps?.mode).toBe('protected');
+    expect(actionProps?.infoMessage).toContain('is a root branch');
+    expect(actionProps?.primaryLabel).toBe('Use root branch (no worktree)');
+    expect(actionProps?.secondaryLabel).toBe('Create new branch from this branch');
+
+    await act(async () => {
+      actionProps?.onUseExisting();
+      await Promise.resolve();
+      await Promise.resolve();
+    });
+
+    expect(switchToProtectedBranchSpy).toHaveBeenCalledWith({
+      branchName: 'main',
+      repoRoot: expect.any(String),
+      remoteRef: null,
+    });
+
+    expect(navigateToMock).toHaveBeenCalledWith('ai-tool-selector');
+    expect(aiToolProps).not.toHaveLength(0);
+  });
+});