gitforest 0.1.0 → 1.0.0

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

@@ -1,274 +0,0 @@
-/**
- * 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

@@ -1,250 +0,0 @@
-/**
- * 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

@@ -1,72 +0,0 @@
-/**
- * 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";