gitforest 0.1.0 → 1.0.0

package/test/unit/git/commands.test.ts

@@ -1,269 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach } from "bun:test";
-import {
-  isGitRepo,
-  getGitRoot,
-  getGitStatusPorcelain,
-  getCurrentBranch,
-  getRemoteUrl,
-  getLastCommitDate,
-  initGit,
-  listSubmodules,
-  isSubmodule,
-} from "../../../src/git/commands.ts";
-import {
-  createTempDir,
-  cleanupTempDir,
-  createMockGitRepo,
-  createMockProject,
-  createMockRepoWithSubmodule,
-} from "../fixtures/setup.ts";
-
-describe("isGitRepo", () => {
-  let tempDir: string;
-
-  beforeEach(() => {
-    tempDir = createTempDir("git-commands-test");
-  });
-
-  afterEach(() => {
-    cleanupTempDir(tempDir);
-  });
-
-  test("returns true for git repository", async () => {
-    const repoPath = await createMockGitRepo(tempDir, "test-repo");
-    const result = await isGitRepo(repoPath);
-    expect(result).toBe(true);
-  });
-
-  test("returns false for non-git directory", async () => {
-    const projectPath = createMockProject(tempDir, "non-git", "package.json");
-    const result = await isGitRepo(projectPath);
-    expect(result).toBe(false);
-  });
-
-  test("returns false for non-existent directory", async () => {
-    const result = await isGitRepo("/non/existent/path");
-    expect(result).toBe(false);
-  });
-});
-
-describe("getGitRoot", () => {
-  let tempDir: string;
-
-  beforeEach(() => {
-    tempDir = createTempDir("git-root-test");
-  });
-
-  afterEach(() => {
-    cleanupTempDir(tempDir);
-  });
-
-  test("returns git root path", async () => {
-    const repoPath = await createMockGitRepo(tempDir, "test-repo");
-    const result = await getGitRoot(repoPath);
-    expect(result).toBe(repoPath);
-  });
-
-  test("returns null for non-git directory", async () => {
-    const projectPath = createMockProject(tempDir, "non-git", "package.json");
-    const result = await getGitRoot(projectPath);
-    expect(result).toBeNull();
-  });
-});
-
-describe("getGitStatusPorcelain", () => {
-  let tempDir: string;
-
-  beforeEach(() => {
-    tempDir = createTempDir("git-status-test");
-  });
-
-  afterEach(() => {
-    cleanupTempDir(tempDir);
-  });
-
-  test("returns empty string for clean repo", async () => {
-    const repoPath = await createMockGitRepo(tempDir, "clean-repo");
-    const result = await getGitStatusPorcelain(repoPath);
-    expect(result.trim()).toBe("");
-  });
-
-  test("returns modified status for changed files", async () => {
-    const repoPath = await createMockGitRepo(tempDir, "dirty-repo", {
-      withChanges: true,
-    });
-    const result = await getGitStatusPorcelain(repoPath);
-    expect(result).toContain("M");
-    expect(result).toContain("README.md");
-  });
-
-  test("returns untracked status for new files", async () => {
-    const repoPath = await createMockGitRepo(tempDir, "untracked-repo", {
-      withUntracked: true,
-    });
-    const result = await getGitStatusPorcelain(repoPath);
-    expect(result).toContain("??");
-    expect(result).toContain("untracked.txt");
-  });
-
-  test("returns staged status for staged files", async () => {
-    const repoPath = await createMockGitRepo(tempDir, "staged-repo", {
-      withStaged: true,
-    });
-    const result = await getGitStatusPorcelain(repoPath);
-    expect(result).toContain("A");
-    expect(result).toContain("staged.txt");
-  });
-});
-
-describe("getCurrentBranch", () => {
-  let tempDir: string;
-
-  beforeEach(() => {
-    tempDir = createTempDir("git-branch-test");
-  });
-
-  afterEach(() => {
-    cleanupTempDir(tempDir);
-  });
-
-  test("returns main/master branch for new repo", async () => {
-    const repoPath = await createMockGitRepo(tempDir, "test-repo");
-    const result = await getCurrentBranch(repoPath);
-    // Git version dependent - could be main or master
-    expect(["main", "master"]).toContain(result);
-  });
-
-  test("returns unknown for non-git directory", async () => {
-    const projectPath = createMockProject(tempDir, "non-git", "package.json");
-    const result = await getCurrentBranch(projectPath);
-    expect(result).toBe("unknown");
-  });
-});
-
-describe("getRemoteUrl", () => {
-  let tempDir: string;
-
-  beforeEach(() => {
-    tempDir = createTempDir("git-remote-test");
-  });
-
-  afterEach(() => {
-    cleanupTempDir(tempDir);
-  });
-
-  test("returns null when no remote configured", async () => {
-    const repoPath = await createMockGitRepo(tempDir, "no-remote-repo");
-    const result = await getRemoteUrl(repoPath);
-    expect(result).toBeNull();
-  });
-});
-
-describe("getLastCommitDate", () => {
-  let tempDir: string;
-
-  beforeEach(() => {
-    tempDir = createTempDir("git-date-test");
-  });
-
-  afterEach(() => {
-    cleanupTempDir(tempDir);
-  });
-
-  test("returns Date object for repo with commits", async () => {
-    const repoPath = await createMockGitRepo(tempDir, "dated-repo");
-    const result = await getLastCommitDate(repoPath);
-    expect(result).toBeInstanceOf(Date);
-    expect(result!.getTime()).toBeLessThanOrEqual(Date.now());
-  });
-
-  test("returns null for non-git directory", async () => {
-    const projectPath = createMockProject(tempDir, "non-git", "package.json");
-    const result = await getLastCommitDate(projectPath);
-    expect(result).toBeNull();
-  });
-});
-
-describe("initGit", () => {
-  let tempDir: string;
-
-  beforeEach(() => {
-    tempDir = createTempDir("git-init-test");
-  });
-
-  afterEach(() => {
-    cleanupTempDir(tempDir);
-  });
-
-  test("initializes git in directory", async () => {
-    const projectPath = createMockProject(tempDir, "init-test", "package.json");
-
-    // Verify not a git repo before
-    expect(await isGitRepo(projectPath)).toBe(false);
-
-    // Initialize git
-    const result = await initGit(projectPath);
-    expect(result).toBe(true);
-
-    // Verify it's now a git repo
-    expect(await isGitRepo(projectPath)).toBe(true);
-  });
-});
-
-describe("listSubmodules", () => {
-  let tempDir: string;
-
-  beforeEach(() => {
-    tempDir = createTempDir("git-submodule-test");
-  });
-
-  afterEach(() => {
-    cleanupTempDir(tempDir);
-  });
-
-  test("returns empty array for repo without submodules", async () => {
-    const repoPath = await createMockGitRepo(tempDir, "no-submodules");
-    const result = await listSubmodules(repoPath);
-    expect(result).toEqual([]);
-  });
-
-  test("returns submodule info for repo with submodules", async () => {
-    const { parentPath } = await createMockRepoWithSubmodule(
-      tempDir,
-      "parent",
-      "submodule"
-    );
-    const result = await listSubmodules(parentPath);
-
-    expect(result).toHaveLength(1);
-    expect(result[0]?.path).toBe("submodule");
-  });
-});
-
-describe("isSubmodule", () => {
-  let tempDir: string;
-
-  beforeEach(() => {
-    tempDir = createTempDir("git-is-submodule-test");
-  });
-
-  afterEach(() => {
-    cleanupTempDir(tempDir);
-  });
-
-  test("returns false for regular git repo", async () => {
-    const repoPath = await createMockGitRepo(tempDir, "regular-repo");
-    const result = await isSubmodule(repoPath);
-    expect(result).toBe(false);
-  });
-
-  test("returns true for submodule", async () => {
-    const { submodulePath } = await createMockRepoWithSubmodule(
-      tempDir,
-      "parent",
-      "submodule"
-    );
-    const result = await isSubmodule(submodulePath);
-    expect(result).toBe(true);
-  });
-});

package/test/unit/git/operations.test.ts

@@ -1,322 +0,0 @@
-/**
- * Tests for git operations module
- */
-
-import { describe, test, expect, beforeEach, afterEach } from "bun:test";
-import {
-  initGitInProject,
-  pullProject,
-  pushProject,
-  fetchProject,
-  addRemoteToProject,
-  refreshProjectStatuses,
-} from "../../../src/git/operations.ts";
-import { createTempDir, cleanupTempDir, createMockGitRepo } from "../fixtures/setup.ts";
-import { writeFile } from "fs/promises";
-import { join } from "path";
-import { $ } from "bun";
-import type { Project } from "../../../src/types/index.ts";
-
-describe("Git Operations", () => {
-  let tempDir: string;
-
-  beforeEach(() => {
-    tempDir = createTempDir("git-operations");
-  });
-
-  afterEach(() => {
-    cleanupTempDir(tempDir);
-  });
-
-  describe("initGitInProject", () => {
-    test("initializes git repository successfully", async () => {
-      const repoPath = join(tempDir, "new-repo");
-      
-      // Create directory first - initGit doesn't create it
-      await $`mkdir -p ${repoPath}`.quiet();
-      
-      const result = await initGitInProject(repoPath);
-      
-      expect(result.success).toBe(true);
-      expect(result.operation).toBe("init");
-      expect(result.projectPath).toBe(repoPath);
-      expect(result.message).toBe("Git repository initialized");
-      expect(result.duration).toBeGreaterThanOrEqual(0);
-    });
-
-    test("handles initialization failure", async () => {
-      // Use a file instead of directory to cause failure
-      const invalidPath = join(tempDir, "not-a-dir.txt");
-      await writeFile(invalidPath, "This is a file, not a directory");
-      
-      const result = await initGitInProject(invalidPath);
-      
-      expect(result.success).toBe(false);
-      expect(result.operation).toBe("init");
-      expect(result.projectPath).toBe(invalidPath);
-      expect(result.error).toBeDefined();
-      expect(result.duration).toBeGreaterThanOrEqual(0);
-    });
-  });
-
-  describe("pullProject", () => {
-    test("pulls changes successfully", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "pull-test");
-      
-      // Pull will fail because there's no remote configured yet
-      // So we expect success to be false
-      const result = await pullProject(repoPath);
-      
-      expect(result.success).toBe(false);
-      expect(result.operation).toBe("pull");
-      expect(result.projectPath).toBe(repoPath);
-      expect(result.error).toBeDefined();
-      expect(result.duration).toBeGreaterThanOrEqual(0);
-    });
-
-    test("handles pull failure", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "pull-fail");
-      
-      // Pull will fail because there's no remote configured
-      const result = await pullProject(repoPath);
-      
-      expect(result.success).toBe(false);
-      expect(result.operation).toBe("pull");
-      expect(result.projectPath).toBe(repoPath);
-      expect(result.error).toBeDefined();
-      expect(result.duration).toBeGreaterThanOrEqual(0);
-    });
-  });
-
-  describe("pushProject", () => {
-    test("pushes changes successfully", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "push-test");
-      
-      // Add a remote and make a commit
-      await writeFile(join(repoPath, "test.txt"), "content");
-      await $`git -C ${repoPath} add test.txt`.quiet();
-      await $`git -C ${repoPath} commit -m "test"`.quiet();
-      
-      const result = await pushProject(repoPath);
-      
-      // Push will fail because remote doesn't actually exist
-      expect(result.success).toBe(false);
-      expect(result.operation).toBe("push");
-      expect(result.projectPath).toBe(repoPath);
-      expect(result.error).toBeDefined();
-      expect(result.duration).toBeGreaterThanOrEqual(0);
-    });
-
-    test("pushes with setUpstream flag", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "push-upstream");
-      
-      // Add a remote and make a commit
-      await writeFile(join(repoPath, "test.txt"), "content");
-      await $`git -C ${repoPath} add test.txt`.quiet();
-      await $`git -C ${repoPath} commit -m "test"`.quiet();
-      
-      const result = await pushProject(repoPath, true);
-      
-      // Push will fail because remote doesn't actually exist
-      expect(result.success).toBe(false);
-      expect(result.operation).toBe("push");
-      expect(result.projectPath).toBe(repoPath);
-      expect(result.error).toBeDefined();
-      expect(result.duration).toBeGreaterThanOrEqual(0);
-    });
-
-    test("handles push failure", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "push-fail");
-      
-      // Push will fail because there's no remote configured
-      const result = await pushProject(repoPath);
-      
-      expect(result.success).toBe(false);
-      expect(result.operation).toBe("push");
-      expect(result.projectPath).toBe(repoPath);
-      expect(result.error).toBeDefined();
-      expect(result.duration).toBeGreaterThanOrEqual(0);
-    });
-  });
-
-  describe("fetchProject", () => {
-    test("fetches clean repo successfully", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "fetch-success");
-      
-      const result = await fetchProject(repoPath);
-      
-      expect(result.success).toBe(true);
-      expect(result.operation).toBe("fetch-all");
-      expect(result.projectPath).toBe(repoPath);
-      expect(result.message).toBe("Fetch all successful");
-      expect(result.duration).toBeGreaterThan(0);
-    });
-  });
-
-  describe("addRemoteToProject", () => {
-    test("adds remote successfully", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "add-remote");
-      
-      const result = await addRemoteToProject(
-        repoPath,
-        "https://github.com/test/repo.git",
-        "origin"
-      );
-      
-      expect(result.success).toBe(true);
-      expect(result.operation).toBe("add-remote");
-      expect(result.projectPath).toBe(repoPath);
-      expect(result.message).toBe("Remote 'origin' added");
-      expect(result.duration).toBeGreaterThan(0);
-    });
-
-    test("adds remote with custom name", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "add-custom-remote");
-      
-      const result = await addRemoteToProject(
-        repoPath,
-        "https://github.com/test/upstream.git",
-        "upstream"
-      );
-      
-      expect(result.success).toBe(true);
-      expect(result.operation).toBe("add-remote");
-      expect(result.projectPath).toBe(repoPath);
-      expect(result.message).toBe("Remote 'upstream' added");
-      expect(result.duration).toBeGreaterThan(0);
-    });
-
-    test("handles add remote failure - invalid URL", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "add-remote-fail");
-      
-      const result = await addRemoteToProject(
-        repoPath,
-        "invalid-url",
-        "origin"
-      );
-      
-      // Git accepts invalid URLs - it only fails when trying to fetch/push
-      expect(result.success).toBe(true);
-      expect(result.operation).toBe("add-remote");
-      expect(result.projectPath).toBe(repoPath);
-      expect(result.message).toBe("Remote 'origin' added");
-      expect(result.duration).toBeGreaterThanOrEqual(0);
-    });
-
-    test("handles add remote failure - remote exists", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "add-remote-exists");
-      
-      // Add a remote first
-      await writeFile(join(repoPath, "test.txt"), "content");
-      await $`git -C ${repoPath} remote add origin https://github.com/test/repo.git`.quiet();
-      
-      const result = await addRemoteToProject(
-        repoPath,
-        "https://github.com/test/repo2.git",
-        "origin"
-      );
-      
-      // addRemote returns false on failure but doesn't throw
-      expect(result.success).toBe(false);
-      expect(result.operation).toBe("add-remote");
-      expect(result.projectPath).toBe(repoPath);
-      expect(result.error).toBeDefined(); // No error string, just success: false
-      expect(result.duration).toBeGreaterThanOrEqual(0);
-    });
-  });
-
-  describe("refreshProjectStatuses", () => {
-    test("refreshes statuses for multiple projects", async () => {
-      const projects: Project[] = [];
-      
-      // Create multiple mock repos
-      for (let i = 0; i < 3; i++) {
-        const repoPath = await createMockGitRepo(tempDir, `repo-${i}`);
-        projects.push({
-          id: `repo-${i}`,
-          name: `repo-${i}`,
-          path: repoPath,
-          type: "git",
-          projectMarker: null,
-          status: null,
-          submodule: null,
-          lastScanned: new Date(),
-          lastModified: null,
-        });
-      }
-      
-      const results = await refreshProjectStatuses(projects);
-      
-      expect(results.size).toBe(3);
-      
-      // Check that each project was updated
-      for (const project of projects) {
-        const updated = results.get(project.id);
-        expect(updated).toBeTruthy();
-        expect(updated?.lastScanned.getTime()).toBeGreaterThan(
-          project.lastScanned.getTime()
-        );
-        expect(updated?.status).toBeTruthy();
-      }
-    });
-
-    test("handles non-git projects gracefully", async () => {
-      const projects: Project[] = [
-        {
-          id: "non-git-1",
-          name: "non-git-1",
-          path: tempDir,
-          type: "non-git",
-          projectMarker: "package.json",
-          status: null,
-          submodule: null,
-          lastScanned: new Date(),
-          lastModified: null,
-        },
-        {
-          id: "non-git-2",
-          name: "non-git-2",
-          path: join(tempDir, "empty"),
-          type: "non-git",
-          projectMarker: null,
-          status: null,
-          submodule: null,
-          lastScanned: new Date(),
-          lastModified: null,
-        },
-      ];
-      
-      const results = await refreshProjectStatuses(projects);
-      
-      // refreshProjectStatuses filters out non-git projects
-      expect(results.size).toBe(0);
-    });
-
-    test("handles errors gracefully", async () => {
-      const projects: Project[] = [
-        {
-          id: "error-repo",
-          name: "error-repo",
-          path: "/invalid/path",
-          type: "git",
-          projectMarker: null,
-          status: null,
-          submodule: null,
-          lastScanned: new Date(),
-          lastModified: null,
-        },
-      ];
-      
-      const results = await refreshProjectStatuses(projects);
-      
-      expect(results.size).toBe(1);
-      
-      // Error should be handled, project returned unchanged
-      const errorRepo = results.get("error-repo");
-      expect(errorRepo).toBeTruthy();
-      // Status should be set even on error (hasCommits returns false)
-      expect(errorRepo?.status).toBeDefined();
-      expect(errorRepo?.status?.hasCommits).toBe(false);
-    });
-  });
-});