gitforest 0.1.0

package/test/unit/operations/batch.test.ts

@@ -0,0 +1,216 @@
+/**
+ * Tests for batch operations using service mocks
+ * 
+ * NOTE: This file must NOT have any module mocks as it tests real implementations.
+ * We restore any mocks at the start to ensure isolation.
+ */
+
+import { describe, test, expect, afterAll, mock } from "bun:test";
+
+// Restore any mocks from other test files before importing real modules
+mock.restore();
+
+import {
+  batchPull,
+  batchPush,
+  batchFetch,
+  batchRefreshStatus,
+} from "../../../src/operations/batch.ts";
+import {
+  createMockGitService,
+  createSpyGitService,
+  createSuccessResult,
+  createFailureResult,
+  defaultMockStatus,
+  createAheadStatus,
+} from "../mocks/git-service.ts";
+import {
+  createMockProject,
+  createAheadProject,
+  createNonGitProject,
+} from "../mocks/project.ts";
+
+describe("batch operations", () => {
+  describe("batchPull", () => {
+    test("pulls projects with remotes", async () => {
+      const { service, calls } = createSpyGitService();
+      const projects = [
+        createMockProject({ name: "repo-1" }),
+        createMockProject({ name: "repo-2" }),
+      ];
+
+      const result = await batchPull(projects, { gitService: service });
+
+      expect(result.total).toBe(2);
+      expect(result.successful).toBe(2);
+      expect(result.failed).toBe(0);
+      expect(calls.filter((c) => c.method === "pull")).toHaveLength(2);
+    });
+
+    test("skips projects without remotes", async () => {
+      const { service, calls } = createSpyGitService();
+      const projects = [
+        createMockProject({
+          name: "with-remote",
+          status: { ...defaultMockStatus, hasRemote: true },
+        }),
+        createMockProject({
+          name: "no-remote",
+          status: { ...defaultMockStatus, hasRemote: false },
+        }),
+      ];
+
+      const result = await batchPull(projects, { gitService: service });
+
+      expect(result.total).toBe(1); // Only one has remote
+      expect(calls.filter((c) => c.method === "pull")).toHaveLength(1);
+    });
+
+    test("skips non-git projects", async () => {
+      const { service, calls } = createSpyGitService();
+      const projects = [
+        createMockProject({ name: "git-repo" }),
+        createNonGitProject("npm-package"),
+      ];
+
+      const result = await batchPull(projects, { gitService: service });
+
+      expect(result.total).toBe(1);
+      expect(calls.filter((c) => c.method === "pull")).toHaveLength(1);
+    });
+
+    test("handles pull failures", async () => {
+      const service = createMockGitService({
+        pullResult: (path) =>
+          path.includes("fail")
+            ? createFailureResult("pull", "Network error", path)
+            : createSuccessResult("pull", path),
+      });
+
+      const projects = [
+        createMockProject({ name: "success-repo", path: "/test/success-repo" }),
+        createMockProject({ name: "fail-repo", path: "/test/fail-repo" }),
+      ];
+
+      const result = await batchPull(projects, { gitService: service });
+
+      expect(result.total).toBe(2);
+      expect(result.successful).toBe(1);
+      expect(result.failed).toBe(1);
+    });
+
+    test("reports progress during pull", async () => {
+      const { service } = createSpyGitService();
+      const projects = [
+        createMockProject({ name: "repo-1" }),
+        createMockProject({ name: "repo-2" }),
+        createMockProject({ name: "repo-3" }),
+      ];
+
+      const progressCalls: [number, number][] = [];
+      await batchPull(projects, {
+        gitService: service,
+        concurrency: 2,
+        onProgress: (completed, total) => {
+          progressCalls.push([completed, total]);
+        },
+      });
+
+      expect(progressCalls.length).toBeGreaterThan(0);
+      // Last call should have all projects completed
+      const lastCall = progressCalls[progressCalls.length - 1]!;
+      expect(lastCall[0]).toBe(3); // completed
+      expect(lastCall[1]).toBe(3); // total
+    });
+  });
+
+  describe("batchPush", () => {
+    test("pushes projects that are ahead", async () => {
+      const { service, calls } = createSpyGitService();
+      const projects = [
+        createAheadProject("ahead-repo", 3),
+        createMockProject({ name: "clean-repo" }), // Not ahead
+      ];
+
+      const result = await batchPush(projects, { gitService: service });
+
+      expect(result.total).toBe(1); // Only one is ahead
+      expect(result.successful).toBe(1);
+      expect(calls.filter((c) => c.method === "push")).toHaveLength(1);
+    });
+
+    test("skips projects without remotes even if ahead status", async () => {
+      const { service, calls } = createSpyGitService();
+      const projects = [
+        createMockProject({
+          name: "ahead-no-remote",
+          status: {
+            ...createAheadStatus(3),
+            hasRemote: false,
+          },
+        }),
+      ];
+
+      const result = await batchPush(projects, { gitService: service });
+
+      expect(result.total).toBe(0);
+      expect(calls.filter((c) => c.method === "push")).toHaveLength(0);
+    });
+  });
+
+  describe("batchFetch", () => {
+    test("fetches all projects with remotes", async () => {
+      const { service, calls } = createSpyGitService();
+      const projects = [
+        createMockProject({ name: "repo-1" }),
+        createMockProject({ name: "repo-2" }),
+      ];
+
+      const result = await batchFetch(projects, { gitService: service });
+
+      expect(result.total).toBe(2);
+      expect(result.successful).toBe(2);
+      expect(calls.filter((c) => c.method === "fetchAll")).toHaveLength(2);
+    });
+  });
+
+  describe("batchRefreshStatus", () => {
+    test("refreshes status for git projects", async () => {
+      const { service, calls } = createSpyGitService();
+      const projects = [
+        createMockProject({ name: "repo-1", id: "id-1" }),
+        createMockProject({ name: "repo-2", id: "id-2" }),
+        createNonGitProject("npm-package"),
+      ];
+
+      const results = await batchRefreshStatus(projects, { gitService: service });
+
+      // Should have refreshed 2 git projects
+      expect(results.size).toBe(2);
+      expect(results.has("id-1")).toBe(true);
+      expect(results.has("id-2")).toBe(true);
+      expect(calls.filter((c) => c.method === "getStatus")).toHaveLength(2);
+    });
+
+    test("preserves project data on status refresh", async () => {
+      const { service } = createSpyGitService();
+      const project = createMockProject({
+        name: "my-repo",
+        id: "my-id",
+        path: "/test/my-repo",
+      });
+
+      const results = await batchRefreshStatus([project], { gitService: service });
+
+      const refreshed = results.get("my-id")!;
+      expect(refreshed.name).toBe("my-repo");
+      expect(refreshed.path).toBe("/test/my-repo");
+      expect(refreshed.lastScanned).toBeDefined();
+    });
+  });
+});
+
+// Restore all mocks after all tests complete
+afterAll(() => {
+  mock.restore();
+});