gitforest 0.1.0 → 1.1.0

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

@@ -1,442 +0,0 @@
-/**
- * Tests for Git service implementation
- * Tests the actual bunGitService implementation
- */
-
-import { describe, test, expect, beforeEach, afterEach } from "bun:test";
-import { bunGitService } from "../../../src/services/git.ts";
-import { GIT_TIMEOUTS } from "../../../src/constants.ts";
-import { TimeoutError } from "../../../src/utils/timeout.ts";
-import {
-  createTempDir,
-  cleanupTempDir,
-  createMockGitRepo,
-  createMockRepoWithSubmodule,
-} from "../fixtures/setup.ts";
-import { mkdir, writeFile } from "fs/promises";
-import { join } from "path";
-import { $ } from "bun";
-
-describe("Git Service - bunGitService", () => {
-  let tempDir: string;
-
-  beforeEach(() => {
-    tempDir = createTempDir("git-service-test");
-  });
-
-  afterEach(() => {
-    cleanupTempDir(tempDir);
-  });
-
-  describe("Repository info methods", () => {
-    test("isGitRepo returns true for git repository", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "test-repo");
-      const result = await bunGitService.isGitRepo(repoPath);
-      expect(result).toBe(true);
-    });
-
-    test("isGitRepo returns false for non-git directory", async () => {
-      const nonGitPath = join(tempDir, "non-git");
-      await mkdir(nonGitPath, { recursive: true });
-      const result = await bunGitService.isGitRepo(nonGitPath);
-      expect(result).toBe(false);
-    });
-
-    test("getGitRoot returns git root path", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "test-repo");
-      const result = await bunGitService.getGitRoot(repoPath);
-      expect(result).toBe(repoPath);
-    });
-
-    test("getGitRoot returns null for non-git directory", async () => {
-      const nonGitPath = join(tempDir, "non-git");
-      await mkdir(nonGitPath, { recursive: true });
-      const result = await bunGitService.getGitRoot(nonGitPath);
-      expect(result).toBeNull();
-    });
-
-    test("isSubmodule returns false for regular repo", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "regular-repo");
-      const result = await bunGitService.isSubmodule(repoPath);
-      expect(result).toBe(false);
-    });
-
-    test("isSubmodule returns true for submodule", async () => {
-      const { submodulePath } = await createMockRepoWithSubmodule(
-        tempDir,
-        "parent",
-        "submodule"
-      );
-      const result = await bunGitService.isSubmodule(submodulePath);
-      expect(result).toBe(true);
-    });
-
-    test("getSubmoduleParent returns parent path for submodule", async () => {
-      const { parentPath, submodulePath } = await createMockRepoWithSubmodule(
-        tempDir,
-        "parent",
-        "submodule"
-      );
-      const result = await bunGitService.getSubmoduleParent(submodulePath);
-      expect(result).toBe(parentPath);
-    });
-
-    test("getSubmoduleParent returns null for regular repo", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "regular-repo");
-      const result = await bunGitService.getSubmoduleParent(repoPath);
-      expect(result).toBeNull();
-    });
-  });
-
-  describe("Status methods", () => {
-    test("getStatus returns comprehensive GitStatus for clean repo", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "clean-repo");
-      const status = await bunGitService.getStatus(repoPath);
-
-      expect(status.isDirty).toBe(false);
-      expect(status.hasUnstagedChanges).toBe(false);
-      expect(status.hasStagedChanges).toBe(false);
-      expect(status.hasUntrackedFiles).toBe(false);
-      expect(status.modifiedCount).toBe(0);
-      expect(status.stagedCount).toBe(0);
-      expect(status.untrackedCount).toBe(0);
-      expect(status.hasCommits).toBe(true);
-      expect(status.isAhead).toBe(false);
-      expect(status.isBehind).toBe(false);
-      expect(status.isOutOfSync).toBe(false);
-    });
-
-    test("getStatus detects unstaged changes", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "dirty-repo", {
-        withChanges: true,
-      });
-      const status = await bunGitService.getStatus(repoPath);
-
-      expect(status.isDirty).toBe(true);
-      expect(status.hasUnstagedChanges).toBe(true);
-      expect(status.modifiedCount).toBeGreaterThan(0);
-    });
-
-    test("getStatusPorcelain returns raw porcelain output", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "porcelain-repo");
-      const result = await bunGitService.getStatusPorcelain(repoPath);
-      expect(typeof result).toBe("string");
-      expect(result.trim()).toBe("");
-    });
-
-    test("getStatusPorcelain handles timeout", async () => {
-      // Create a very slow git command by using a non-existent path
-      // This will fail quickly, but tests the timeout wrapper
-      const result = await bunGitService.getStatusPorcelain("/non/existent/path");
-      expect(result).toBe("");
-    });
-
-    test("getCurrentBranch returns branch name", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "branch-repo");
-      const result = await bunGitService.getCurrentBranch(repoPath);
-      expect(["main", "master"]).toContain(result);
-    });
-
-    test("getCurrentBranch returns unknown for non-git directory", async () => {
-      const nonGitPath = join(tempDir, "non-git");
-      await mkdir(nonGitPath, { recursive: true });
-      const result = await bunGitService.getCurrentBranch(nonGitPath);
-      expect(result).toBe("unknown");
-    });
-
-    test("getTrackingBranch returns null when no tracking branch", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "no-tracking");
-      const result = await bunGitService.getTrackingBranch(repoPath);
-      expect(result).toBeNull();
-    });
-
-    test("countUnpushedCommits returns 0 when no tracking branch", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "no-tracking");
-      const result = await bunGitService.countUnpushedCommits(repoPath);
-      expect(result).toBe(0);
-    });
-
-    test("countUnpulledCommits returns 0 when no tracking branch", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "no-tracking");
-      const result = await bunGitService.countUnpulledCommits(repoPath);
-      expect(result).toBe(0);
-    });
-
-    test("getRemoteUrl returns null when no remote", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "no-remote");
-      const result = await bunGitService.getRemoteUrl(repoPath);
-      expect(result).toBeNull();
-    });
-
-    test("getRemoteUrl returns URL when remote configured", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "with-remote");
-      await $`git -C ${repoPath} remote add origin https://github.com/test/repo.git`.quiet();
-      
-      const result = await bunGitService.getRemoteUrl(repoPath);
-      expect(result).toBe("https://github.com/test/repo.git");
-    });
-
-    test("getLastCommitDate returns Date object", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "dated-repo");
-      const result = await bunGitService.getLastCommitDate(repoPath);
-      
-      expect(result).toBeInstanceOf(Date);
-      expect(result!.getTime()).toBeLessThanOrEqual(Date.now());
-    });
-
-    test("getLastCommitDate returns null for non-git directory", async () => {
-      const nonGitPath = join(tempDir, "non-git");
-      await mkdir(nonGitPath, { recursive: true });
-      const result = await bunGitService.getLastCommitDate(nonGitPath);
-      expect(result).toBeNull();
-    });
-
-    test("getRemoteLastCommitDate returns null for non-existent branch", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "no-remote-branch");
-      const result = await bunGitService.getRemoteLastCommitDate(repoPath, "origin/nonexistent");
-      expect(result).toBeNull();
-    });
-
-    test("listSubmodules returns empty array for repo without submodules", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "no-submodules");
-      const result = await bunGitService.listSubmodules(repoPath);
-      expect(result).toEqual([]);
-    });
-
-    test("listSubmodules returns submodule info for repo with submodules", async () => {
-      const { parentPath } = await createMockRepoWithSubmodule(
-        tempDir,
-        "parent",
-        "submodule"
-      );
-      const result = await bunGitService.listSubmodules(parentPath);
-
-      expect(result).toHaveLength(1);
-      expect(result[0]?.path).toBe("submodule");
-      // Submodule status can be: - (not initialized), + (different commit), ' ' (initialized and up to date), U (unmerged conflicts)
-      // The status character is the first character of the submodule status line
-      // It can be various characters, let's just check it's a single character
-      expect(result[0]?.status).toHaveLength(1);
-    });
-  });
-
-  describe("Operations with timeouts", () => {
-    test("init creates repository and returns OperationResult", async () => {
-      const projectPath = join(tempDir, "init-test");
-      await mkdir(projectPath, { recursive: true });
-
-      const result = await bunGitService.init(projectPath);
-
-      expect(result.success).toBe(true);
-      expect(result.operation).toBe("init");
-      expect(result.projectPath).toBe(projectPath);
-      expect(result.message).toBe("Git repository initialized");
-      expect(typeof result.duration).toBe("number");
-      expect(result.duration).toBeGreaterThanOrEqual(0);
-    });
-
-    test("init returns error when init fails", async () => {
-      // Try to init in a non-existent directory
-      const result = await bunGitService.init("/non/existent/path");
-
-      expect(result.success).toBe(false);
-      expect(result.operation).toBe("init");
-      expect(result.error).toBeDefined();
-      expect(typeof result.duration).toBe("number");
-    });
-
-    test("pull returns success when no remote (graceful failure)", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "no-remote-pull");
-      
-      const result = await bunGitService.pull(repoPath);
-
-      expect(result.success).toBe(false);
-      expect(result.operation).toBe("pull");
-      expect(result.error).toBeDefined();
-      expect(typeof result.duration).toBe("number");
-    });
-
-    test("pull includes timeout error message", async () => {
-      // This test simulates a timeout scenario
-      // We can't easily trigger an actual timeout in tests, but we can verify the error handling
-      const repoPath = await createMockGitRepo(tempDir, "pull-timeout");
-      
-      const result = await bunGitService.pull(repoPath);
-      
-      // Should fail gracefully with some error message
-      if (!result.success) {
-        expect(result.error).toBeDefined();
-      }
-    });
-
-    test("push returns success when no remote (graceful failure)", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "no-remote-push");
-      
-      const result = await bunGitService.push(repoPath);
-
-      expect(result.success).toBe(false);
-      expect(result.operation).toBe("push");
-      expect(result.error).toBeDefined();
-      expect(typeof result.duration).toBe("number");
-    });
-
-    test("push with setUpstream flag", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "push-upstream");
-      
-      const result = await bunGitService.push(repoPath, true);
-
-      expect(result.operation).toBe("push");
-      expect(typeof result.duration).toBe("number");
-      // Will fail without remote, but tests the setUpstream parameter
-    });
-
-    test("push includes timeout error message", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "push-timeout");
-      
-      const result = await bunGitService.push(repoPath);
-      
-      // Should fail gracefully with some error message
-      if (!result.success) {
-        expect(result.error).toBeDefined();
-      }
-    });
-
-    test("fetch succeeds even with no remotes", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "fetch-no-remote");
-      
-      const result = await bunGitService.fetch(repoPath);
-
-      // fetch may fail with no remotes, but should handle gracefully
-      expect(result.operation).toBe("fetch");
-      expect(typeof result.duration).toBe("number");
-    });
-
-    test("fetch includes timeout error message", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "fetch-timeout");
-      
-      const result = await bunGitService.fetch(repoPath);
-      
-      // Should succeed or fail gracefully
-      expect(typeof result.duration).toBe("number");
-    });
-
-    test("fetchAll succeeds with no remotes", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "fetch-all-no-remote");
-      
-      const result = await bunGitService.fetchAll(repoPath);
-
-      expect(result.success).toBe(true);
-      expect(result.operation).toBe("fetch-all");
-      expect(result.message).toBe("Fetch all successful");
-      expect(typeof result.duration).toBe("number");
-    });
-
-    test("addRemote adds remote successfully", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "add-remote");
-      
-      const result = await bunGitService.addRemote(
-        repoPath,
-        "https://github.com/test/repo.git",
-        "origin"
-      );
-
-      expect(result.success).toBe(true);
-      expect(result.operation).toBe("add-remote");
-      expect(result.message).toBe("Remote 'origin' added");
-      expect(typeof result.duration).toBe("number");
-    });
-
-    test("addRemote with custom name", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "add-custom-remote");
-      
-      const result = await bunGitService.addRemote(
-        repoPath,
-        "https://github.com/test/repo.git",
-        "upstream"
-      );
-
-      expect(result.success).toBe(true);
-      expect(result.message).toBe("Remote 'upstream' added");
-    });
-
-    test("clone clones repository successfully", async () => {
-      // Create a bare repo to clone from
-      const bareRepoPath = join(tempDir, "bare-repo");
-      await $`git init --bare ${bareRepoPath}`.quiet();
-      
-      // Create a source repo and push to bare
-      const sourceRepoPath = await createMockGitRepo(tempDir, "source-repo");
-      await $`git -C ${sourceRepoPath} remote add origin ${bareRepoPath}`.quiet();
-      // Get the actual branch name (could be main or master)
-      const branchName = (await $`git -C ${sourceRepoPath} branch --show-current`.text()).trim();
-      await $`git -C ${sourceRepoPath} push origin ${branchName}`.quiet();
-      
-      // Clone from bare repo
-      const cloneTarget = join(tempDir, "cloned-repo");
-      const result = await bunGitService.clone(
-        bareRepoPath,
-        cloneTarget
-      );
-
-      expect(result.success).toBe(true);
-      expect(result.operation).toBe("clone");
-      expect(result.projectPath).toBe(cloneTarget);
-      expect(result.message).toBe("Clone successful");
-      expect(typeof result.duration).toBe("number");
-    });
-
-    test("clone returns error on clone failure", async () => {
-      const cloneTarget = join(tempDir, "failed-clone");
-      
-      const result = await bunGitService.clone(
-        "/non/existent/path",
-        cloneTarget
-      );
-
-      expect(result.success).toBe(false);
-      expect(result.operation).toBe("clone");
-      expect(result.error).toBeDefined();
-      expect(typeof result.duration).toBe("number");
-    });
-  });
-
-  describe("Edge cases", () => {
-    test("handles non-existent paths gracefully", async () => {
-      const nonExistentPath = "/non/existent/path";
-      
-      expect(await bunGitService.isGitRepo(nonExistentPath)).toBe(false);
-      expect(await bunGitService.getGitRoot(nonExistentPath)).toBeNull();
-      expect(await bunGitService.getCurrentBranch(nonExistentPath)).toBe("unknown");
-      expect(await bunGitService.getRemoteUrl(nonExistentPath)).toBeNull();
-      expect(await bunGitService.getLastCommitDate(nonExistentPath)).toBeNull();
-    });
-
-    test("includes duration in all OperationResults", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "duration-test");
-      
-      const operations = [
-        () => bunGitService.init(join(tempDir, "duration-init")),
-        () => bunGitService.pull(repoPath),
-        () => bunGitService.push(repoPath),
-        () => bunGitService.fetch(repoPath),
-        () => bunGitService.fetchAll(repoPath),
-        () => bunGitService.addRemote(repoPath, "https://example.com/repo.git"),
-      ];
-      
-      for (const operation of operations) {
-        const result = await operation();
-        expect(typeof result.duration).toBe("number");
-        expect(result.duration).toBeGreaterThanOrEqual(0);
-      }
-    });
-
-    test("uses correct timeout constants", () => {
-      // Verify timeout constants exist and are reasonable
-      expect(GIT_TIMEOUTS.STATUS).toBeGreaterThan(0);
-      expect(GIT_TIMEOUTS.PULL).toBeGreaterThan(0);
-      expect(GIT_TIMEOUTS.PUSH).toBeGreaterThan(0);
-      expect(GIT_TIMEOUTS.FETCH).toBeGreaterThan(0);
-      expect(GIT_TIMEOUTS.CLONE).toBeGreaterThan(0);
-    });
-  });
-});