gitforest 0.1.0

package/test/unit/mocks/project.ts

@@ -0,0 +1,148 @@
+/**
+ * Mock factory for Project objects
+ * Provides configurable mock projects for testing
+ */
+
+import type { Project } from "../../../src/types/index";
+import { defaultMockStatus, createDirtyStatus, createAheadStatus } from "./git-service";
+
+let projectIdCounter = 0;
+
+/**
+ * Create a mock project for testing
+ */
+export function createMockProject(overrides?: Partial<Project>): Project {
+  projectIdCounter++;
+  const id = overrides?.id ?? `mock-project-${projectIdCounter}`;
+  const name = overrides?.name ?? `project-${projectIdCounter}`;
+  const type = overrides?.type ?? "git";
+
+  const baseProject: Project = {
+    id,
+    name,
+    path: overrides?.path ?? `/test/projects/${name}`,
+    type,
+    projectMarker: type === "non-git" ? (overrides?.projectMarker ?? "package.json") : null,
+    status: type !== "non-git" ? (overrides?.status ?? { ...defaultMockStatus }) : null,
+    submodule: null,
+    lastScanned: overrides?.lastScanned ?? new Date(),
+    lastModified: overrides?.lastModified ?? (type === "non-git" ? new Date() : null),
+  };
+
+  return { ...baseProject, ...overrides };
+}
+
+/**
+ * Create a clean git project (no changes)
+ */
+export function createCleanProject(name?: string): Project {
+  return createMockProject({
+    name: name ?? `clean-project-${++projectIdCounter}`,
+    type: "git",
+    status: { ...defaultMockStatus },
+  });
+}
+
+/**
+ * Create a dirty git project (uncommitted changes)
+ */
+export function createDirtyProject(name?: string): Project {
+  return createMockProject({
+    name: name ?? `dirty-project-${++projectIdCounter}`,
+    type: "git",
+    status: createDirtyStatus(),
+  });
+}
+
+/**
+ * Create a project with unpushed commits
+ */
+export function createAheadProject(name?: string, commits = 3): Project {
+  return createMockProject({
+    name: name ?? `ahead-project-${++projectIdCounter}`,
+    type: "git",
+    status: createAheadStatus(commits),
+  });
+}
+
+/**
+ * Create a non-git project
+ */
+export function createNonGitProject(name?: string, marker = "package.json"): Project {
+  return createMockProject({
+    name: name ?? `non-git-project-${++projectIdCounter}`,
+    type: "non-git",
+    projectMarker: marker,
+    status: null,
+  });
+}
+
+/**
+ * Create a submodule project
+ */
+export function createSubmoduleProject(
+  name?: string,
+  parentPath = "/test/parent"
+): Project {
+  const submoduleName = name ?? `submodule-${++projectIdCounter}`;
+  return createMockProject({
+    name: submoduleName,
+    type: "git-submodule",
+    submodule: {
+      parentPath,
+      relativePath: submoduleName,
+      configuredCommit: "abc123def456",
+      currentCommit: "abc123def456",
+      isInitialized: true,
+    },
+  });
+}
+
+/**
+ * Create a batch of diverse projects for testing
+ */
+export function createMockProjectBatch(): {
+  clean: Project[];
+  dirty: Project[];
+  ahead: Project[];
+  behind: Project[];
+  nonGit: Project[];
+} {
+  return {
+    clean: [
+      createCleanProject("clean-1"),
+      createCleanProject("clean-2"),
+    ],
+    dirty: [
+      createDirtyProject("dirty-1"),
+      createDirtyProject("dirty-2"),
+    ],
+    ahead: [
+      createAheadProject("ahead-1", 2),
+      createAheadProject("ahead-2", 5),
+    ],
+    behind: [
+      createMockProject({
+        name: "behind-1",
+        type: "git",
+        status: {
+          ...defaultMockStatus,
+          unpulledCommits: 3,
+          isBehind: true,
+          isOutOfSync: true,
+        },
+      }),
+    ],
+    nonGit: [
+      createNonGitProject("npm-project", "package.json"),
+      createNonGitProject("rust-project", "Cargo.toml"),
+    ],
+  };
+}
+
+/**
+ * Reset the project ID counter (useful between tests)
+ */
+export function resetProjectIdCounter(): void {
+  projectIdCounter = 0;
+}

package/test/unit/mocks/state-mocks.ts

@@ -0,0 +1,187 @@
+/**
+ * Complete mock exports for state modules
+ * 
+ * These exports include ALL functions from their respective modules
+ * to prevent incomplete module mocking from breaking other tests.
+ * 
+ * When using mock.module(), use these complete exports to avoid
+ * "Export not found" errors when tests run together.
+ */
+
+import { mock } from "bun:test";
+import type { Project, GitHubRepoInfo, UnifiedRepo } from "../../../src/types/index";
+
+/**
+ * Complete mock for src/state/actions.ts
+ * Includes all 34 action creators
+ */
+export function createActionsMock() {
+  return {
+    // Project actions
+    setProjects: (payload: Project[]) => ({ type: "SET_PROJECTS", payload }),
+    setLoading: (payload: boolean) => ({ type: "SET_LOADING", payload }),
+    setError: (payload: string | null) => ({ type: "SET_ERROR", payload }),
+    setMessage: (payload: string | null) => ({ type: "SET_MESSAGE", payload }),
+    updateProject: (id: string, updates: Partial<Project>) => ({ type: "UPDATE_PROJECT", payload: { id, updates } }),
+    
+    // Cursor and selection actions
+    moveCursor: (index: number) => ({ type: "MOVE_CURSOR", payload: index }),
+    toggleSelection: (index: number) => ({ type: "TOGGLE_SELECTION", payload: index }),
+    selectAll: () => ({ type: "SELECT_ALL" }),
+    deselectAll: () => ({ type: "DESELECT_ALL" }),
+    setScrollOffset: (offset: number) => ({ type: "SET_SCROLL_OFFSET", payload: offset }),
+    
+    // Filter and sort actions
+    setFilter: (text: string) => ({ type: "SET_FILTER", payload: text }),
+    setSort: (by: string, direction: string) => ({ type: "SET_SORT", payload: { by, direction } }),
+    cycleSort: () => ({ type: "CYCLE_SORT" }),
+    setQuickFilter: (filter: string) => ({ type: "SET_QUICK_FILTER", payload: filter }),
+    setLanguageFilter: (language: string | null) => ({ type: "SET_LANGUAGE_FILTER", payload: language }),
+    
+    // Mode actions
+    setMode: (mode: string) => ({ type: "SET_MODE", payload: mode }),
+    setViewMode: (mode: string) => ({ type: "SET_VIEW_MODE", payload: mode }),
+    
+    // Action progress
+    startAction: (action: string) => ({ type: "START_ACTION", payload: action }),
+    endAction: () => ({ type: "END_ACTION" }),
+    updateProgress: (current: number, total: number) => ({ type: "UPDATE_PROGRESS", payload: { current, total } }),
+    
+    // GitHub actions
+    setGitHubRepos: (repos: GitHubRepoInfo[]) => ({ type: "SET_GITHUB_REPOS", payload: repos }),
+    setUnifiedRepos: (repos: UnifiedRepo[]) => ({ type: "SET_UNIFIED_REPOS", payload: repos }),
+    setGitHubLoading: (loading: boolean) => ({ type: "SET_GITHUB_LOADING", payload: loading }),
+    setGitHubError: (error: string | null) => ({ type: "SET_GITHUB_ERROR", payload: error }),
+    setRefreshing: (refreshing: boolean) => ({ type: "SET_REFRESHING", payload: refreshing }),
+    
+    // Clone dialog actions
+    showCloneDialog: (repos: UnifiedRepo[], directories: any[], selectedDirIndex: number, useSSH: boolean) => 
+      ({ type: "SHOW_CLONE_DIALOG", payload: { repos, directories, selectedDirIndex, useSSH } }),
+    hideCloneDialog: () => ({ type: "HIDE_CLONE_DIALOG" }),
+    updateCloneDialog: (updates: any) => ({ type: "UPDATE_CLONE_DIALOG", payload: updates }),
+    cloneRepoStart: (repoId: string) => ({ type: "CLONE_REPO_START", payload: repoId }),
+    cloneRepoComplete: (id: string, localPath: string) => ({ type: "CLONE_REPO_COMPLETE", payload: { id, localPath } }),
+    cloneRepoFailed: (id: string, error: string) => ({ type: "CLONE_REPO_FAILED", payload: { id, error } }),
+    
+    // Detail modal actions
+    showDetailModal: (modal: any) => ({ type: "SHOW_DETAIL_MODAL", payload: modal }),
+    hideDetailModal: () => ({ type: "HIDE_DETAIL_MODAL" }),
+    updateDetailModal: (updates: any) => ({ type: "UPDATE_DETAIL_MODAL", payload: updates }),
+    
+    // Confirm dialog actions  
+    showConfirmDialog: (dialog: any) => ({ type: "SHOW_CONFIRM_DIALOG", payload: dialog }),
+    hideConfirmDialog: () => ({ type: "HIDE_CONFIRM_DIALOG" }),
+  };
+}
+
+/**
+ * Complete mock for src/state/store.tsx
+ * Includes all exported hooks and components
+ */
+export function createStoreMock(stateGetter?: () => any, dispatch?: (action: any) => void) {
+  const defaultState = {
+    projects: [],
+    isLoading: false,
+    error: null,
+    message: null,
+    cursorIndex: 0,
+    selectedIndices: new Set(),
+    scrollOffset: 0,
+    filterText: "",
+    quickFilter: "all",
+    sortBy: "status",
+    sortDirection: "desc",
+    mode: "normal",
+    actionInProgress: null,
+    actionProgress: null,
+    confirmDialog: null,
+    viewMode: "combined",
+    detailModal: null,
+    cloneDialog: null,
+    refreshing: false,
+    unifiedRepos: [],
+    githubRepos: [],
+    isLoadingGitHub: false,
+    githubError: null,
+    isRefreshing: false,
+    languageFilter: null,
+  };
+
+  return {
+    useStore: () => ({
+      state: stateGetter ? stateGetter() : defaultState,
+      dispatch: dispatch || mock(() => {}),
+    }),
+    useFilteredProjects: () => [],
+    useSelectedProjects: () => [],
+    useFilteredUnifiedRepos: () => [],
+    useSelectedUnifiedRepos: () => [],
+    StoreProvider: ({ children }: { children: any }) => children,
+    StoreContext: { Provider: ({ children }: any) => children },
+  };
+}
+
+/**
+ * Complete mock for src/scanner/index.ts
+ * Includes all exported functions
+ */
+export function createScannerMock() {
+  return {
+    scanAllDirectories: mock(() => Promise.resolve([])),
+    scanWithCache: mock(() => Promise.resolve([])),
+    sortProjects: (projects: any[]) => projects,
+    filterProjects: (projects: any[]) => projects,
+    getCacheStats: mock(() => Promise.resolve({ projectCount: 0, oldestScan: null, newestScan: null })),
+    clearCache: mock(() => Promise.resolve()),
+  };
+}
+
+/**
+ * Complete mock for src/operations/batch.ts
+ * Includes all exported functions
+ */
+export function createBatchMock() {
+  const emptyResult = { total: 0, successful: 0, failed: 0, results: [], duration: 0 };
+  return {
+    batchPull: mock(() => Promise.resolve(emptyResult)),
+    batchPush: mock(() => Promise.resolve(emptyResult)),
+    batchFetch: mock(() => Promise.resolve(emptyResult)),
+    batchRefreshStatus: mock(() => Promise.resolve(emptyResult)),
+  };
+}
+
+/**
+ * Complete mock for src/git/operations.ts
+ * Includes all exported functions
+ */
+export function createGitOperationsMock() {
+  return {
+    initGitInProject: mock(() => Promise.resolve({ success: true })),
+    getGitRemote: mock(() => Promise.resolve(null)),
+    setGitRemote: mock(() => Promise.resolve({ success: true })),
+  };
+}
+
+/**
+ * Complete mock for src/github/cache.ts
+ * Includes all exported functions
+ */
+export function createGitHubCacheMock() {
+  return {
+    fetchGitHubReposWithCache: mock(() => Promise.resolve({ repos: [], error: null })),
+    loadGitHubReposFromCache: mock(() => Promise.resolve([])),
+    clearGitHubCache: mock(() => Promise.resolve()),
+  };
+}
+
+/**
+ * Complete mock for src/github/unified.ts
+ * Includes all exported functions
+ */
+export function createGitHubUnifiedMock() {
+  return {
+    cloneGitHubRepo: mock(() => Promise.resolve({ success: true, path: "/test/path" })),
+    createUnifiedView: mock(() => []),
+    fetchUnifiedRepos: mock(() => Promise.resolve([])),
+  };
+}

package/test/unit/mocks/unified.ts

@@ -0,0 +1,169 @@
+/**
+ * Mock factory for UnifiedRepo and related types
+ * Provides configurable mocks for unified repository view
+ */
+
+import type { 
+  UnifiedRepo, 
+  GitHubRepoInfo, 
+  UnifiedAppState,
+  Project
+} from "../../../src/types/index";
+import { createMockProject } from "./project";
+
+/**
+ * Create a mock GitHub repository info
+ */
+export function createMockGitHubRepoInfo(overrides?: Partial<GitHubRepoInfo>): GitHubRepoInfo {
+  const name = overrides?.name ?? "test-repo";
+  const owner = overrides?.owner ?? "testuser";
+  const fullName = overrides?.fullName ?? `${owner}/${name}`;
+
+  return {
+    name,
+    fullName,
+    owner,
+    description: overrides?.description ?? `A test repository: ${name}`,
+    htmlUrl: overrides?.htmlUrl ?? `https://github.com/${owner}/${name}`,
+    sshUrl: overrides?.sshUrl ?? `git@github.com:${owner}/${name}.git`,
+    cloneUrl: overrides?.cloneUrl ?? `https://github.com/${owner}/${name}.git`,
+    isPrivate: overrides?.isPrivate ?? false,
+    isArchived: overrides?.isArchived ?? false,
+    isFork: overrides?.isFork ?? false,
+    pushedAt: overrides?.pushedAt ?? new Date(),
+    updatedAt: overrides?.updatedAt ?? new Date(),
+    defaultBranch: overrides?.defaultBranch ?? "main",
+    language: overrides?.language ?? "TypeScript",
+    size: overrides?.size ?? 1024,
+    stargazersCount: overrides?.stargazersCount ?? 10,
+    forksCount: overrides?.forksCount ?? 5,
+    openIssuesCount: overrides?.openIssuesCount ?? 2,
+    watchersCount: overrides?.watchersCount ?? 15,
+    topics: overrides?.topics ?? ["typescript", "test"],
+    license: overrides?.license ?? "MIT",
+    hasIssues: overrides?.hasIssues ?? true,
+    hasWiki: overrides?.hasWiki ?? true,
+    hasDiscussions: overrides?.hasDiscussions ?? false,
+    ...overrides,
+  };
+}
+
+/**
+ * Create a mock unified repository
+ */
+export function createMockUnifiedRepo(overrides?: Partial<UnifiedRepo>): UnifiedRepo {
+  const name = overrides?.name ?? "test-repo";
+  const id = overrides?.id ?? `unified-${name}`;
+  const source = overrides?.source ?? "local";
+
+  // Create local project if not explicitly null and source allows it
+  let local: Project | null = null;
+  if (overrides?.local !== null && (source === "local" || source === "both")) {
+    local = overrides?.local ?? createMockProject({ 
+      name,
+      path: `/test/projects/${name}` 
+    });
+  }
+
+  // Create GitHub info if not explicitly null and source allows it
+  let github: GitHubRepoInfo | null = null;
+  if (overrides?.github !== null && (source === "github" || source === "both")) {
+    github = overrides?.github ?? createMockGitHubRepoInfo({ name });
+  }
+
+  return {
+    id,
+    name,
+    source,
+    local,
+    github,
+    isCloned: overrides?.isCloned ?? (local !== null),
+    isOnGitHub: overrides?.isOnGitHub ?? (github !== null),
+    localPath: overrides?.localPath ?? (local ? local.path : null),
+    ...overrides,
+  };
+}
+
+/**
+ * Create a mock unified app state
+ */
+export function createMockUnifiedAppState(overrides?: Partial<UnifiedAppState>): UnifiedAppState {
+  const viewMode = overrides?.viewMode ?? "combined";
+  const projects = overrides?.projects ?? [];
+  const githubRepos = overrides?.githubRepos ?? [];
+  const unifiedRepos = overrides?.unifiedRepos ?? [];
+
+  return {
+    // AppState properties
+    projects,
+    isLoading: overrides?.isLoading ?? false,
+    error: overrides?.error ?? null,
+    message: overrides?.message ?? null,
+    cursorIndex: overrides?.cursorIndex ?? 0,
+    selectedIndices: overrides?.selectedIndices ?? new Set(),
+    scrollOffset: overrides?.scrollOffset ?? 0,
+    filterText: overrides?.filterText ?? "",
+    quickFilter: overrides?.quickFilter ?? "all",
+    sortBy: overrides?.sortBy ?? "status",
+    sortDirection: overrides?.sortDirection ?? "desc",
+    mode: overrides?.mode ?? "normal",
+    actionInProgress: overrides?.actionInProgress ?? null,
+    actionProgress: overrides?.actionProgress ?? null,
+    confirmDialog: overrides?.confirmDialog ?? null,
+
+    // UnifiedAppState properties
+    viewMode,
+    githubRepos,
+    unifiedRepos,
+    isLoadingGitHub: overrides?.isLoadingGitHub ?? false,
+    githubError: overrides?.githubError ?? null,
+    isRefreshing: overrides?.isRefreshing ?? false,
+    cloneDialog: overrides?.cloneDialog ?? null,
+    detailModal: overrides?.detailModal ?? null,
+    languageFilter: overrides?.languageFilter ?? null,
+
+    ...overrides,
+  };
+}
+
+/**
+ * Helper to create a local-only unified repo
+ */
+export function createLocalOnlyUnifiedRepo(name?: string, overrides?: Partial<UnifiedRepo>): UnifiedRepo {
+  return createMockUnifiedRepo({
+    name: name ?? "local-only-repo",
+    source: "local",
+    github: null,
+    isOnGitHub: false,
+    ...overrides,
+  });
+}
+
+/**
+ * Helper to create a GitHub-only unified repo
+ */
+export function createGitHubOnlyUnifiedRepo(name?: string, overrides?: Partial<UnifiedRepo>): UnifiedRepo {
+  return createMockUnifiedRepo({
+    name: name ?? "github-only-repo",
+    source: "github",
+    local: null,
+    isCloned: false,
+    localPath: null,
+    ...overrides,
+  });
+}
+
+/**
+ * Helper to create a fully synced unified repo (exists both locally and on GitHub)
+ */
+export function createSyncedUnifiedRepo(name?: string, overrides?: Partial<UnifiedRepo>): UnifiedRepo {
+  const repoName = name ?? "synced-repo";
+  return createMockUnifiedRepo({
+    name: repoName,
+    source: "both",
+    isCloned: true,
+    isOnGitHub: true,
+    localPath: `/test/projects/${repoName}`,
+    ...overrides,
+  });
+}