Add test coverage

tests/coordination_test.ts

@@ -0,0 +1,134 @@
+import {
+  assertEquals,
+  assertRejects,
+} from "std/assert/mod.ts";
+import { describe, it, afterEach, beforeEach } from "std/testing/bdd.ts";
+import { assertSpyCalls, spy, stub } from "std/testing/mock.ts";
+import {
+  isPidRunning,
+  isLockValid,
+  waitForAuthentication,
+} from "../src/lib/coordination.ts";
+
+/**
+ * Basic tests for the coordination module
+ */
+describe("coordination", () => {
+  describe("isPidRunning", () => {
+    it("returns false when Deno.Command throws an error", async () => {
+      const originalCommand = Deno.Command;
+      try {
+        // @ts-ignore - Replace Deno.Command with a function that throws
+        Deno.Command = () => {
+          throw new Error("Test error");
+        };
+
+        const result = await isPidRunning(1234);
+        assertEquals(result, false);
+      } finally {
+        // Restore original Command
+        Deno.Command = originalCommand;
+      }
+    });
+
+    if (Deno.build.os === "linux" || Deno.build.os === "darwin") {
+      it("checks if a process is running on non-Windows by using kill command", async () => {
+        // Just verify it runs without error - actual functionality depends on the OS
+        const result = await isPidRunning(Deno.pid);
+        // Our own process should be running
+        assertEquals(typeof result, "boolean");
+      });
+    } else if (Deno.build.os === "windows") {
+      it("checks if a process is running on Windows by using tasklist command", async () => {
+        // Just verify it runs without error - actual functionality depends on the OS
+        const result = await isPidRunning(Deno.pid);
+        // Our own process should be running
+        assertEquals(typeof result, "boolean");
+      });
+    }
+  });
+
+  describe("isLockValid", () => {
+    const mockLockData = {
+      pid: 1234, // A likely non-existent PID
+      port: 8000,
+      timestamp: Date.now() - (31 * 60 * 1000), // Expired (31 minutes old)
+    };
+
+    it("returns false for expired lockfile", async () => {
+      const result = await isLockValid(mockLockData);
+      assertEquals(result, false);
+    });
+
+    it("returns false for non-existent process", async () => {
+      // Find a PID that's unlikely to exist
+      let testPid = 999999;
+      while (await isPidRunning(testPid)) {
+        testPid += 1000;
+      }
+
+      const validTimestampData = {
+        ...mockLockData,
+        pid: testPid,
+        timestamp: Date.now(), // Not expired
+      };
+
+      const result = await isLockValid(validTimestampData);
+      assertEquals(result, false);
+    });
+  });
+
+  describe("waitForAuthentication", () => {
+    let fetchStub: ReturnType<typeof stub>;
+    let setTimeoutStub: ReturnType<typeof stub>;
+
+    beforeEach(() => {
+      // @ts-ignore - Required for testing
+      setTimeoutStub = stub(globalThis, "setTimeout", (callback: TimerHandler) => {
+        if (typeof callback === "function") {
+          callback();
+        }
+        return 1 as unknown as ReturnType<typeof setTimeout>;
+      });
+    });
+
+    afterEach(() => {
+      // Clean up
+      if (fetchStub) fetchStub.restore();
+      setTimeoutStub.restore();
+    });
+
+    it("returns true when authentication completes", async () => {
+      // Mock fetch to simulate a successful authentication
+      // @ts-ignore - Required for testing
+      fetchStub = stub(globalThis, "fetch", () =>
+        Promise.resolve(new Response("Auth completed", { status: 200 }))
+      );
+
+      const result = await waitForAuthentication(8000);
+      assertEquals(result, true);
+    });
+
+    it("returns false for unexpected status", async () => {
+      // Mock fetch to simulate an error response
+      // @ts-ignore - Required for testing
+      fetchStub = stub(globalThis, "fetch", () =>
+        Promise.resolve(new Response("Error", { status: 500 }))
+      );
+
+      const result = await waitForAuthentication(8000);
+      assertEquals(result, false);
+    });
+
+    it("returns false when fetch fails", async () => {
+      // Mock fetch to simulate a network error
+      // @ts-ignore - Required for testing
+      fetchStub = stub(globalThis, "fetch", () =>
+        Promise.reject(new Error("Network error"))
+      );
+
+      const result = await waitForAuthentication(8000);
+      assertEquals(result, false);
+    });
+  });
+});