gitforest 0.1.0

package/test/unit/mocks/git-service.ts

@@ -0,0 +1,274 @@
+/**
+ * Mock factory for GitService
+ * Provides configurable mock implementations for testing
+ */
+
+import type { GitService } from "../../../src/services/git.ts";
+import type { GitStatus, OperationResult } from "../../../src/types/index.ts";
+import type { SubmoduleEntry } from "../../../src/services/types.ts";
+
+/**
+ * Default mock git status - clean repo
+ */
+export const defaultMockStatus: GitStatus = {
+  hasUnstagedChanges: false,
+  hasStagedChanges: false,
+  hasUntrackedFiles: false,
+  modifiedCount: 0,
+  stagedCount: 0,
+  untrackedCount: 0,
+  currentBranch: "main",
+  trackingBranch: "origin/main",
+  unpushedCommits: 0,
+  unpulledCommits: 0,
+  hasRemote: true,
+  remoteUrl: "git@github.com:user/repo.git",
+  lastLocalCommit: new Date(),
+  lastRemoteActivity: new Date(),
+  hasCommits: true,
+  isDirty: false,
+  isAhead: false,
+  isBehind: false,
+  isOutOfSync: false,
+};
+
+/**
+ * Create a dirty status (uncommitted changes)
+ */
+export function createDirtyStatus(overrides?: Partial<GitStatus>): GitStatus {
+  return {
+    ...defaultMockStatus,
+    hasUnstagedChanges: true,
+    modifiedCount: 2,
+    isDirty: true,
+    ...overrides,
+  };
+}
+
+/**
+ * Create an ahead status (unpushed commits)
+ */
+export function createAheadStatus(commits = 3, overrides?: Partial<GitStatus>): GitStatus {
+  return {
+    ...defaultMockStatus,
+    unpushedCommits: commits,
+    isAhead: true,
+    isOutOfSync: true,
+    ...overrides,
+  };
+}
+
+/**
+ * Create a behind status (needs pull)
+ */
+export function createBehindStatus(commits = 2, overrides?: Partial<GitStatus>): GitStatus {
+  return {
+    ...defaultMockStatus,
+    unpulledCommits: commits,
+    isBehind: true,
+    isOutOfSync: true,
+    ...overrides,
+  };
+}
+
+/**
+ * Create a no-remote status
+ */
+export function createNoRemoteStatus(overrides?: Partial<GitStatus>): GitStatus {
+  return {
+    ...defaultMockStatus,
+    hasRemote: false,
+    remoteUrl: null,
+    trackingBranch: null,
+    ...overrides,
+  };
+}
+
+/**
+ * Success operation result
+ */
+export function createSuccessResult(
+  operation: string,
+  path = "/test/path"
+): OperationResult {
+  return {
+    success: true,
+    projectPath: path,
+    operation,
+    message: `${operation} successful`,
+    duration: 100,
+  };
+}
+
+/**
+ * Failure operation result
+ */
+export function createFailureResult(
+  operation: string,
+  error = "Operation failed",
+  path = "/test/path"
+): OperationResult {
+  return {
+    success: false,
+    projectPath: path,
+    operation,
+    error,
+    duration: 50,
+  };
+}
+
+/**
+ * GitService mock configuration
+ */
+export interface MockGitServiceConfig {
+  isRepo?: boolean | ((path: string) => boolean);
+  gitRoot?: string | null | ((path: string) => string | null);
+  isSubmodule?: boolean | ((path: string) => boolean);
+  submoduleParent?: string | null;
+  status?: GitStatus | ((path: string) => GitStatus);
+  porcelain?: string;
+  currentBranch?: string;
+  trackingBranch?: string | null;
+  unpushedCommits?: number;
+  unpulledCommits?: number;
+  remoteUrl?: string | null;
+  lastCommitDate?: Date | null;
+  remoteLastCommitDate?: Date | null;
+  submodules?: SubmoduleEntry[];
+
+  // Operation results
+  initResult?: OperationResult | ((path: string) => OperationResult);
+  pullResult?: OperationResult | ((path: string) => OperationResult);
+  pushResult?: OperationResult | ((path: string) => OperationResult);
+  fetchResult?: OperationResult | ((path: string) => OperationResult);
+  fetchAllResult?: OperationResult | ((path: string) => OperationResult);
+  addRemoteResult?: OperationResult;
+  cloneResult?: OperationResult;
+}
+
+/**
+ * Create a mock GitService for testing
+ */
+export function createMockGitService(config: MockGitServiceConfig = {}): GitService {
+  const resolveValue = <T>(
+    value: T | ((path: string) => T) | undefined,
+    path: string,
+    defaultValue: T
+  ): T => {
+    if (value === undefined) return defaultValue;
+    if (typeof value === "function") return (value as (path: string) => T)(path);
+    return value;
+  };
+
+  return {
+    async isGitRepo(path: string): Promise<boolean> {
+      return resolveValue(config.isRepo, path, true);
+    },
+
+    async getGitRoot(path: string): Promise<string | null> {
+      return resolveValue(config.gitRoot, path, path);
+    },
+
+    async isSubmodule(path: string): Promise<boolean> {
+      return resolveValue(config.isSubmodule, path, false);
+    },
+
+    async getSubmoduleParent(_path: string): Promise<string | null> {
+      return config.submoduleParent ?? null;
+    },
+
+    async getStatus(path: string): Promise<GitStatus> {
+      return resolveValue(config.status, path, defaultMockStatus);
+    },
+
+    async getStatusPorcelain(_path: string): Promise<string> {
+      return config.porcelain ?? "";
+    },
+
+    async getCurrentBranch(_path: string): Promise<string> {
+      return config.currentBranch ?? "main";
+    },
+
+    async getTrackingBranch(_path: string): Promise<string | null> {
+      return config.trackingBranch ?? "origin/main";
+    },
+
+    async countUnpushedCommits(_path: string): Promise<number> {
+      return config.unpushedCommits ?? 0;
+    },
+
+    async countUnpulledCommits(_path: string): Promise<number> {
+      return config.unpulledCommits ?? 0;
+    },
+
+    async getRemoteUrl(_path: string, _remote?: string): Promise<string | null> {
+      return config.remoteUrl ?? "git@github.com:user/repo.git";
+    },
+
+    async getLastCommitDate(_path: string): Promise<Date | null> {
+      return config.lastCommitDate ?? new Date();
+    },
+
+    async getRemoteLastCommitDate(_path: string, _remoteBranch?: string): Promise<Date | null> {
+      return config.remoteLastCommitDate ?? new Date();
+    },
+
+    async listSubmodules(_path: string): Promise<SubmoduleEntry[]> {
+      return config.submodules ?? [];
+    },
+
+    async init(path: string): Promise<OperationResult> {
+      return resolveValue(config.initResult, path, createSuccessResult("init", path));
+    },
+
+    async pull(path: string): Promise<OperationResult> {
+      return resolveValue(config.pullResult, path, createSuccessResult("pull", path));
+    },
+
+    async push(path: string, _setUpstream?: boolean): Promise<OperationResult> {
+      return resolveValue(config.pushResult, path, createSuccessResult("push", path));
+    },
+
+    async fetch(path: string): Promise<OperationResult> {
+      return resolveValue(config.fetchResult, path, createSuccessResult("fetch", path));
+    },
+
+    async fetchAll(path: string): Promise<OperationResult> {
+      return resolveValue(config.fetchAllResult, path, createSuccessResult("fetch-all", path));
+    },
+
+    async addRemote(path: string, _url: string, _name?: string): Promise<OperationResult> {
+      return config.addRemoteResult ?? createSuccessResult("add-remote", path);
+    },
+
+    async clone(_url: string, targetDir: string): Promise<OperationResult> {
+      return config.cloneResult ?? createSuccessResult("clone", targetDir);
+    },
+  };
+}
+
+/**
+ * Create a GitService that tracks method calls for assertions
+ */
+export function createSpyGitService(config: MockGitServiceConfig = {}): {
+  service: GitService;
+  calls: { method: string; args: unknown[] }[];
+} {
+  const calls: { method: string; args: unknown[] }[] = [];
+  const base = createMockGitService(config);
+
+  const proxy = new Proxy(base, {
+    get(target, prop) {
+      const original = target[prop as keyof GitService];
+      if (typeof original === "function") {
+        return (...args: unknown[]) => {
+          calls.push({ method: prop as string, args });
+          return (original as Function).apply(target, args);
+        };
+      }
+      return original;
+    },
+  });
+
+  return { service: proxy, calls };
+}

package/test/unit/mocks/github-service.ts

@@ -0,0 +1,250 @@
+/**
+ * Mock factory for GitHubService
+ * Provides configurable mock implementations for testing
+ */
+
+import type { GitHubService } from "../../../src/services/github.ts";
+import type {
+  GitHubUser,
+  GitHubOrg,
+  GitHubRepoData,
+  GetReposOptions,
+  CreateRepoOptions,
+  CloneOptions,
+} from "../../../src/services/types.ts";
+import type { OperationResult } from "../../../src/types/index.ts";
+
+/**
+ * Create a mock GitHub user
+ */
+export function createMockUser(overrides?: Partial<GitHubUser>): GitHubUser {
+  return {
+    login: "testuser",
+    name: "Test User",
+    type: "User",
+    ...overrides,
+  };
+}
+
+/**
+ * Create a mock GitHub org
+ */
+export function createMockOrg(overrides?: Partial<GitHubOrg>): GitHubOrg {
+  return {
+    login: "testorg",
+    description: "A test organization",
+    ...overrides,
+  };
+}
+
+/**
+ * Create a mock GitHub repository
+ */
+export function createMockRepo(overrides?: Partial<GitHubRepoData>): GitHubRepoData {
+  const name = overrides?.name ?? "test-repo";
+  const owner = overrides?.owner?.login ?? "testuser";
+
+  return {
+    id: Math.floor(Math.random() * 1000000),
+    name,
+    fullName: `${owner}/${name}`,
+    description: `A test repository: ${name}`,
+    htmlUrl: `https://github.com/${owner}/${name}`,
+    sshUrl: `git@github.com:${owner}/${name}.git`,
+    cloneUrl: `https://github.com/${owner}/${name}.git`,
+    isPrivate: false,
+    isArchived: false,
+    isFork: false,
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString(),
+    pushedAt: new Date().toISOString(),
+    size: 1024,
+    stargazersCount: 10,
+    forksCount: 5,
+    openIssuesCount: 2,
+    watchersCount: 15,
+    topics: ["typescript", "test"],
+    license: { name: "MIT" },
+    hasIssues: true,
+    hasWiki: true,
+    hasDiscussions: false,
+    language: "TypeScript",
+    defaultBranch: "main",
+    owner: {
+      login: owner,
+      type: "User",
+    },
+    ...overrides,
+  };
+}
+
+/**
+ * Create multiple mock repos
+ */
+export function createMockRepos(count: number, prefix = "repo"): GitHubRepoData[] {
+  return Array.from({ length: count }, (_, i) =>
+    createMockRepo({
+      id: i + 1,
+      name: `${prefix}-${i + 1}`,
+    })
+  );
+}
+
+/**
+ * GitHubService mock configuration
+ */
+export interface MockGitHubServiceConfig {
+  hasToken?: boolean;
+  token?: string | null;
+  user?: GitHubUser;
+  orgs?: GitHubOrg[];
+  userRepos?: GitHubRepoData[];
+  orgRepos?: Map<string, GitHubRepoData[]>;
+  allRepos?: GitHubRepoData[];
+  repo?: GitHubRepoData | null;
+  searchResults?: GitHubRepoData[];
+  createRepoResult?: { success: boolean; url?: string; error?: string };
+  archiveRepoResult?: { success: boolean; error?: string };
+  cloneRepoResult?: OperationResult;
+
+  // For simulating errors
+  throwOnGetUser?: boolean;
+  throwOnGetRepos?: boolean;
+  throwOnGetOrgs?: boolean;
+}
+
+/**
+ * Create a mock GitHubService for testing
+ */
+export function createMockGitHubService(config: MockGitHubServiceConfig = {}): GitHubService {
+  const defaultUser = createMockUser();
+  const defaultOrgs = [createMockOrg()];
+  const defaultRepos = createMockRepos(5);
+
+  return {
+    hasToken(): boolean {
+      return config.hasToken ?? true;
+    },
+
+    getToken(): string | null {
+      if (config.token !== undefined) return config.token;
+      return config.hasToken === false ? null : "mock-token";
+    },
+
+    async getAuthenticatedUser(): Promise<GitHubUser> {
+      if (config.throwOnGetUser) {
+        throw new Error("Failed to get authenticated user");
+      }
+      return config.user ?? defaultUser;
+    },
+
+    async getUserOrgs(): Promise<GitHubOrg[]> {
+      if (config.throwOnGetOrgs) {
+        throw new Error("Failed to get user orgs");
+      }
+      return config.orgs ?? defaultOrgs;
+    },
+
+    async getUserRepos(_options?: GetReposOptions): Promise<GitHubRepoData[]> {
+      if (config.throwOnGetRepos) {
+        throw new Error("Failed to get user repos");
+      }
+      return config.userRepos ?? defaultRepos;
+    },
+
+    async getOrgRepos(org: string, _options?: GetReposOptions): Promise<GitHubRepoData[]> {
+      if (config.throwOnGetRepos) {
+        throw new Error(`Failed to get repos for org ${org}`);
+      }
+      return config.orgRepos?.get(org) ?? [];
+    },
+
+    async getAllRepos(_options?: GetReposOptions): Promise<GitHubRepoData[]> {
+      if (config.throwOnGetRepos) {
+        throw new Error("Failed to get all repos");
+      }
+      return config.allRepos ?? config.userRepos ?? defaultRepos;
+    },
+
+    async getRepo(owner: string, name: string): Promise<GitHubRepoData> {
+      if (config.repo === null) {
+        throw new Error(`Repository ${owner}/${name} not found`);
+      }
+      return config.repo ?? createMockRepo({ name, owner: { login: owner, type: "User" } });
+    },
+
+    async searchRepos(
+      query: string,
+      _options?: { sort?: string; order?: string; perPage?: number }
+    ): Promise<GitHubRepoData[]> {
+      if (config.searchResults) return config.searchResults;
+      // Filter mock repos by query for realistic behavior
+      const repos = config.allRepos ?? config.userRepos ?? defaultRepos;
+      return repos.filter(
+        (r) =>
+          r.name.includes(query) ||
+          r.fullName.includes(query) ||
+          r.description?.includes(query)
+      );
+    },
+
+    async createRepo(
+      options: CreateRepoOptions
+    ): Promise<{ success: boolean; url?: string; error?: string }> {
+      if (config.createRepoResult) return config.createRepoResult;
+      return {
+        success: true,
+        url: `https://github.com/testuser/${options.name}`,
+      };
+    },
+
+    async archiveRepo(_ownerRepo: string): Promise<{ success: boolean; error?: string }> {
+      return config.archiveRepoResult ?? { success: true };
+    },
+
+    async unarchiveRepo(_ownerRepo: string): Promise<{ success: boolean; error?: string }> {
+      return { success: true };
+    },
+
+    async deleteRepo(_ownerRepo: string): Promise<{ success: boolean; error?: string }> {
+      return { success: true };
+    },
+
+    async cloneRepo(repo: GitHubRepoData, options: CloneOptions): Promise<OperationResult> {
+      if (config.cloneRepoResult) return config.cloneRepoResult;
+      return {
+        success: true,
+        projectPath: options.targetDir,
+        operation: "clone",
+        message: `Cloned ${repo.fullName}`,
+        duration: 100,
+      };
+    },
+  };
+}
+
+/**
+ * Create a GitHubService that tracks method calls for assertions
+ */
+export function createSpyGitHubService(config: MockGitHubServiceConfig = {}): {
+  service: GitHubService;
+  calls: { method: string; args: unknown[] }[];
+} {
+  const calls: { method: string; args: unknown[] }[] = [];
+  const base = createMockGitHubService(config);
+
+  const proxy = new Proxy(base, {
+    get(target, prop) {
+      const original = target[prop as keyof GitHubService];
+      if (typeof original === "function") {
+        return (...args: unknown[]) => {
+          calls.push({ method: prop as string, args });
+          return (original as Function).apply(target, args);
+        };
+      }
+      return original;
+    },
+  });
+
+  return { service: proxy, calls };
+}

package/test/unit/mocks/index.ts

@@ -0,0 +1,72 @@
+/**
+ * Test mock factories
+ * Provides configurable mocks for all service interfaces
+ */
+
+// Git Service mocks
+export {
+  createMockGitService,
+  createSpyGitService,
+  defaultMockStatus,
+  createDirtyStatus,
+  createAheadStatus,
+  createBehindStatus,
+  createNoRemoteStatus,
+  createSuccessResult,
+  createFailureResult,
+  type MockGitServiceConfig,
+} from "./git-service";
+
+// GitHub Service mocks
+export {
+  createMockGitHubService,
+  createSpyGitHubService,
+  createMockUser,
+  createMockOrg,
+  createMockRepo,
+  createMockRepos,
+  type MockGitHubServiceConfig,
+} from "./github-service";
+
+// Project factories
+export {
+  createMockProject,
+  createCleanProject,
+  createDirtyProject,
+  createAheadProject,
+  createNonGitProject,
+  createSubmoduleProject,
+  createMockProjectBatch,
+  resetProjectIdCounter,
+} from "./project";
+
+// Unified repo factories
+export {
+  createMockUnifiedRepo,
+  createMockGitHubRepoInfo,
+  createMockUnifiedAppState,
+  createLocalOnlyUnifiedRepo,
+  createGitHubOnlyUnifiedRepo,
+  createSyncedUnifiedRepo,
+} from "./unified";
+
+// Config factories
+export {
+  createMockConfig,
+  createMockDirectoryConfig,
+  createMockCommandConfig,
+  createMinimalConfig,
+  createConfigWithCommands,
+  createMultiDirectoryConfig,
+} from "./config";
+
+// State mocks - complete mock helpers for use with mock.module()
+export {
+  createActionsMock,
+  createStoreMock,
+  createScannerMock,
+  createBatchMock,
+  createGitOperationsMock,
+  createGitHubCacheMock,
+  createGitHubUnifiedMock,
+} from "./state-mocks";