gitforest 0.1.0 → 1.1.0

package/test/unit/scanner/markers.test.ts

@@ -1,150 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach } from "bun:test";
-import {
-  detectProjectMarker,
-  getProjectTypeName,
-  isLikelyProject,
-} from "../../../src/scanner/markers.ts";
-import {
-  createTempDir,
-  cleanupTempDir,
-  createMockGitRepo,
-  createMockProject,
-} from "../fixtures/setup.ts";
-
-describe("detectProjectMarker", () => {
-  let tempDir: string;
-
-  beforeEach(() => {
-    tempDir = createTempDir("marker-test");
-  });
-
-  afterEach(() => {
-    cleanupTempDir(tempDir);
-  });
-
-  test("detects package.json", async () => {
-    const projectPath = createMockProject(tempDir, "node-project", "package.json");
-    const result = await detectProjectMarker(projectPath);
-    expect(result).toBe("package.json");
-  });
-
-  test("detects Cargo.toml", async () => {
-    const projectPath = createMockProject(tempDir, "rust-project", "Cargo.toml");
-    const result = await detectProjectMarker(projectPath);
-    expect(result).toBe("Cargo.toml");
-  });
-
-  test("detects pyproject.toml", async () => {
-    const projectPath = createMockProject(tempDir, "python-project", "pyproject.toml");
-    const result = await detectProjectMarker(projectPath);
-    expect(result).toBe("pyproject.toml");
-  });
-
-  test("detects go.mod", async () => {
-    const projectPath = createMockProject(tempDir, "go-project", "go.mod");
-    const result = await detectProjectMarker(projectPath);
-    expect(result).toBe("go.mod");
-  });
-
-  test("returns null for empty directory", async () => {
-    const { mkdirSync } = await import("fs");
-    const { join } = await import("path");
-    const emptyPath = join(tempDir, "empty");
-    mkdirSync(emptyPath);
-
-    const result = await detectProjectMarker(emptyPath);
-    expect(result).toBeNull();
-  });
-
-  test("returns first marker found when multiple exist", async () => {
-    const { writeFileSync } = await import("fs");
-    const { join } = await import("path");
-    const { mkdirSync } = await import("fs");
-
-    const projectPath = join(tempDir, "multi-marker");
-    mkdirSync(projectPath);
-    writeFileSync(join(projectPath, "package.json"), "{}");
-    writeFileSync(join(projectPath, "Cargo.toml"), "");
-
-    const result = await detectProjectMarker(projectPath);
-    expect(result).not.toBeNull();
-  });
-});
-
-describe("getProjectTypeName", () => {
-  test("returns Node.js for package.json", () => {
-    expect(getProjectTypeName("package.json")).toBe("Node.js");
-  });
-
-  test("returns Rust for Cargo.toml", () => {
-    expect(getProjectTypeName("Cargo.toml")).toBe("Rust");
-  });
-
-  test("returns Python for pyproject.toml", () => {
-    expect(getProjectTypeName("pyproject.toml")).toBe("Python");
-  });
-
-  test("returns Go for go.mod", () => {
-    expect(getProjectTypeName("go.mod")).toBe("Go");
-  });
-
-  test("returns Ruby for Gemfile", () => {
-    expect(getProjectTypeName("Gemfile")).toBe("Ruby");
-  });
-
-  test("returns Java (Maven) for pom.xml", () => {
-    expect(getProjectTypeName("pom.xml")).toBe("Java (Maven)");
-  });
-
-  test("returns Java (Gradle) for build.gradle", () => {
-    expect(getProjectTypeName("build.gradle")).toBe("Java (Gradle)");
-  });
-
-  test("returns Unknown for null", () => {
-    expect(getProjectTypeName(null)).toBe("Unknown");
-  });
-
-  test("returns Unknown for unrecognized marker", () => {
-    expect(getProjectTypeName("unknown.marker")).toBe("Unknown");
-  });
-});
-
-describe("isLikelyProject", () => {
-  let tempDir: string;
-
-  beforeEach(() => {
-    tempDir = createTempDir("likely-project-test");
-  });
-
-  afterEach(() => {
-    cleanupTempDir(tempDir);
-  });
-
-  test("returns true for git repository", async () => {
-    const repoPath = await createMockGitRepo(tempDir, "git-repo");
-    const result = await isLikelyProject(repoPath);
-    expect(result).toBe(true);
-  });
-
-  test("returns true for directory with package.json", async () => {
-    const projectPath = createMockProject(tempDir, "node-project", "package.json");
-    const result = await isLikelyProject(projectPath);
-    expect(result).toBe(true);
-  });
-
-  test("returns true for directory with Cargo.toml", async () => {
-    const projectPath = createMockProject(tempDir, "rust-project", "Cargo.toml");
-    const result = await isLikelyProject(projectPath);
-    expect(result).toBe(true);
-  });
-
-  test("returns false for empty directory", async () => {
-    const { mkdirSync } = await import("fs");
-    const { join } = await import("path");
-    const emptyPath = join(tempDir, "empty");
-    mkdirSync(emptyPath);
-
-    const result = await isLikelyProject(emptyPath);
-    expect(result).toBe(false);
-  });
-});

package/test/unit/scanner/submodules.test.ts

@@ -1,99 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach } from "bun:test";
-import { getSubmoduleInfo, findSubmodules, isSubmoduleOf } from "../../../src/scanner/submodules.ts";
-import {
-  createTempDir,
-  cleanupTempDir,
-  createMockGitRepo,
-  createMockRepoWithSubmodule,
-} from "../fixtures/setup.ts";
-
-describe("getSubmoduleInfo", () => {
-  let tempDir: string;
-
-  beforeEach(() => {
-    tempDir = createTempDir("submodule-info-test");
-  });
-
-  afterEach(() => {
-    cleanupTempDir(tempDir);
-  });
-
-  test("returns null for regular git repo", async () => {
-    const repoPath = await createMockGitRepo(tempDir, "regular-repo");
-    const result = await getSubmoduleInfo(repoPath);
-    expect(result).toBeNull();
-  });
-
-  test("returns submodule info for actual submodule", async () => {
-    const { submodulePath } = await createMockRepoWithSubmodule(
-      tempDir,
-      "parent",
-      "submodule"
-    );
-    const result = await getSubmoduleInfo(submodulePath);
-
-    expect(result).not.toBeNull();
-    expect(result?.relativePath).toBe("submodule");
-    expect(result?.isInitialized).toBe(true);
-  });
-});
-
-describe("findSubmodules", () => {
-  let tempDir: string;
-
-  beforeEach(() => {
-    tempDir = createTempDir("find-submodules-test");
-  });
-
-  afterEach(() => {
-    cleanupTempDir(tempDir);
-  });
-
-  test("returns empty array for repo without submodules", async () => {
-    const repoPath = await createMockGitRepo(tempDir, "no-submodules");
-    const result = await findSubmodules(repoPath);
-    expect(result).toEqual([]);
-  });
-
-  test("returns array of submodule paths", async () => {
-    const { parentPath } = await createMockRepoWithSubmodule(
-      tempDir,
-      "parent",
-      "submodule"
-    );
-    const result = await findSubmodules(parentPath);
-
-    expect(result).toHaveLength(1);
-    expect(result[0]).toContain("submodule");
-  });
-});
-
-describe("isSubmoduleOf", () => {
-  let tempDir: string;
-
-  beforeEach(() => {
-    tempDir = createTempDir("is-submodule-of-test");
-  });
-
-  afterEach(() => {
-    cleanupTempDir(tempDir);
-  });
-
-  test("returns true when path is submodule of parent", async () => {
-    const { parentPath, submodulePath } = await createMockRepoWithSubmodule(
-      tempDir,
-      "parent",
-      "submodule"
-    );
-    const result = await isSubmoduleOf(submodulePath, parentPath);
-    expect(result).toBe(true);
-  });
-
-  test("returns false when path is not submodule", async () => {
-    const parentPath = await createMockGitRepo(tempDir, "parent");
-    const otherRepo = await createMockGitRepo(tempDir, "other");
-
-    const result = await isSubmoduleOf(otherRepo, parentPath);
-    expect(result).toBe(false);
-  });
-});

package/test/unit/services/git-errors.test.ts

@@ -1,190 +0,0 @@
-/**
- * Tests for Git service error handling
- */
-import { describe, test, expect } from "bun:test";
-import { createMockGitService, createFailureResult } from "../mocks/git-service.ts";
-
-describe("Git Service Error Handling", () => {
-  describe("Network Timeout Scenarios", () => {
-    test("should handle fetch timeout errors", async () => {
-      const gitService = createMockGitService({
-        fetchResult: createFailureResult("fetch", "fetch timeout after 30000ms", "/test/repo")
-      });
-
-      const result = await gitService.fetch("/test/repo");
-      
-      expect(result.success).toBe(false);
-      expect(result.error).toContain("timeout");
-      expect(result.duration).toBeGreaterThan(0);
-    });
-
-    test("should handle push timeout errors", async () => {
-      const gitService = createMockGitService({
-        pushResult: createFailureResult("push", "Connection timed out", "/test/repo")
-      });
-
-      const result = await gitService.push("/test/repo");
-      
-      expect(result.success).toBe(false);
-      expect(result.error).toContain("timed out");
-    });
-
-    test("should handle pull timeout errors", async () => {
-      const gitService = createMockGitService({
-        pullResult: createFailureResult("pull", "ETIMEDOUT", "/test/repo")
-      });
-
-      const result = await gitService.pull("/test/repo");
-      
-      expect(result.success).toBe(false);
-      expect(result.error).toContain("ETIMEDOUT");
-    });
-  });
-
-  describe("Permission Denied Scenarios", () => {
-    test("should handle permission denied on clone", async () => {
-      const gitService = createMockGitService({
-        cloneResult: createFailureResult("clone", "Permission denied (publickey)", "/target/dir")
-      });
-
-      const result = await gitService.clone("git@github.com:user/repo.git", "/target/dir");
-      
-      expect(result.success).toBe(false);
-      expect(result.error).toContain("Permission denied");
-    });
-
-    test("should handle permission denied on push", async () => {
-      const gitService = createMockGitService({
-        pushResult: createFailureResult("push", "error: insufficient permission for adding object", "/test/repo")
-      });
-
-      const result = await gitService.push("/test/repo");
-      
-      expect(result.success).toBe(false);
-      expect(result.error).toContain("insufficient permission");
-    });
-
-    test("should handle permission denied on init", async () => {
-      const gitService = createMockGitService({
-        initResult: createFailureResult("init", "Permission denied", "/protected/dir")
-      });
-
-      const result = await gitService.init("/protected/dir");
-      
-      expect(result.success).toBe(false);
-      expect(result.error).toContain("Permission denied");
-    });
-  });
-
-  describe("Repository Not Found Scenarios", () => {
-    test("should handle remote repository not found", async () => {
-      const gitService = createMockGitService({
-        fetchResult: createFailureResult("fetch", "remote repository not found", "/test/repo"),
-        remoteUrl: null
-      });
-
-      const result = await gitService.fetch("/test/repo");
-      
-      expect(result.success).toBe(false);
-      expect(result.error).toContain("not found");
-      expect(result.projectPath).toBe("/test/repo");
-    });
-
-    test("should handle invalid remote URL", async () => {
-      const gitService = createMockGitService({
-        fetchResult: createFailureResult("fetch", "fatal: remote error: repository not found", "/test/repo"),
-        remoteUrl: "invalid-url"
-      });
-
-      const result = await gitService.fetch("/test/repo");
-      
-      expect(result.success).toBe(false);
-      expect(result.error).toContain("repository not found");
-    });
-  });
-
-  describe("Corrupt Repository Handling", () => {
-    test("should handle corrupt index", async () => {
-      const gitService = createMockGitService({
-        status: (path: string) => { throw new Error("bad index file"); }
-      });
-
-      await expect(gitService.getStatus("/corrupt/repo")).rejects.toThrow("bad index file");
-    });
-
-    test("should handle missing objects", async () => {
-      const gitService = createMockGitService({
-        pullResult: createFailureResult("pull", "error: object file is empty", "/corrupt/repo")
-      });
-
-      const result = await gitService.pull("/corrupt/repo");
-      
-      expect(result.success).toBe(false);
-      expect(result.error).toContain("object file is empty");
-    });
-
-    test("should handle HEAD pointing to non-existent ref", async () => {
-      const gitService = createMockGitService({
-        currentBranch: "HEAD"
-      });
-
-      // Mock the actual getCurrentBranch method to throw
-      gitService.getCurrentBranch = async () => {
-        throw new Error("fatal: ambiguous argument 'HEAD': unknown revision");
-      };
-
-      await expect(gitService.getCurrentBranch("/corrupt/repo")).rejects.toThrow("unknown revision");
-    });
-  });
-
-  describe("Submodule Errors", () => {
-    test("should handle uninitialized submodules", async () => {
-      const gitService = createMockGitService({
-        submodules: []
-      });
-
-      const submodules = await gitService.listSubmodules("/repo/with/submodules");
-      expect(submodules).toEqual([]);
-    });
-
-    test("should handle submodule permission issues", async () => {
-      const gitService = createMockGitService({
-        submodules: [{
-          path: "vendor/lib",
-          commit: "abc123",
-          status: " "
-        }],
-        fetchResult: createFailureResult("fetch", "Permission denied in submodule", "/repo/with/submodules")
-      });
-
-      const result = await gitService.fetch("/repo/with/submodules");
-      
-      expect(result.success).toBe(false);
-      expect(result.error).toContain("Permission denied");
-    });
-  });
-
-  describe("Concurrent Operation Errors", () => {
-    test("should handle index lock errors", async () => {
-      const gitService = createMockGitService({
-        pullResult: createFailureResult("pull", "fatal: Unable to create '/.git/index.lock': File exists", "/busy/repo")
-      });
-
-      const result = await gitService.pull("/busy/repo");
-      
-      expect(result.success).toBe(false);
-      expect(result.error).toContain("index.lock");
-    });
-
-    test("should handle packed refs lock errors", async () => {
-      const gitService = createMockGitService({
-        fetchResult: createFailureResult("fetch", "unable to create '.git/packed-refs.lock", "/busy/repo")
-      });
-
-      const result = await gitService.fetch("/busy/repo");
-      
-      expect(result.success).toBe(false);
-      expect(result.error).toContain("packed-refs.lock");
-    });
-  });
-});