gitforest 0.1.0

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

@@ -0,0 +1,442 @@
+/**
+ * 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);
+    });
+  });
+});