perf(test): optimize heavy suites and stabilize lock timing

src/infra/tailscale.test.ts

@@ -1,4 +1,4 @@
-import { afterEach, describe, expect, it, vi } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import * as tailscale from "./tailscale.js";
 
 const {
@@ -12,7 +12,18 @@ const {
 const tailscaleBin = expect.stringMatching(/tailscale$/i);
 
 describe("tailscale helpers", () => {
+  const originalForcedBinary = process.env.OPENCLAW_TEST_TAILSCALE_BINARY;
+
+  beforeEach(() => {
+    process.env.OPENCLAW_TEST_TAILSCALE_BINARY = "tailscale";
+  });
+
   afterEach(() => {
+    if (originalForcedBinary === undefined) {
+      delete process.env.OPENCLAW_TEST_TAILSCALE_BINARY;
+    } else {
+      process.env.OPENCLAW_TEST_TAILSCALE_BINARY = originalForcedBinary;
+    }
     vi.restoreAllMocks();
   });
 
@@ -65,7 +76,6 @@ describe("tailscale helpers", () => {
   it("enableTailscaleServe attempts normal first, then sudo", async () => {
     // 1. First attempt fails
     // 2. Second attempt (sudo) succeeds
-    vi.spyOn(tailscale, "getTailscaleBinary").mockResolvedValue("tailscale");
     const exec = vi
       .fn()
       .mockRejectedValueOnce(new Error("permission denied"))
@@ -89,7 +99,6 @@ describe("tailscale helpers", () => {
   });
 
   it("enableTailscaleServe does NOT use sudo if first attempt succeeds", async () => {
-    vi.spyOn(tailscale, "getTailscaleBinary").mockResolvedValue("tailscale");
     const exec = vi.fn().mockResolvedValue({ stdout: "" });
 
     await enableTailscaleServe(3000, exec as never);
@@ -103,7 +112,6 @@ describe("tailscale helpers", () => {
   });
 
   it("disableTailscaleServe uses fallback", async () => {
-    vi.spyOn(tailscale, "getTailscaleBinary").mockResolvedValue("tailscale");
     const exec = vi
       .fn()
       .mockRejectedValueOnce(new Error("permission denied"))
@@ -125,7 +133,6 @@ describe("tailscale helpers", () => {
     // 1. status (success)
     // 2. enable (fails)
     // 3. enable sudo (success)
-    vi.spyOn(tailscale, "getTailscaleBinary").mockResolvedValue("tailscale");
     const exec = vi
       .fn()
       .mockResolvedValueOnce({ stdout: JSON.stringify({ BackendState: "Running" }) }) // status
@@ -166,7 +173,6 @@ describe("tailscale helpers", () => {
   });
 
   it("enableTailscaleServe skips sudo on non-permission errors", async () => {
-    vi.spyOn(tailscale, "getTailscaleBinary").mockResolvedValue("tailscale");
     const exec = vi.fn().mockRejectedValueOnce(new Error("boom"));
 
     await expect(enableTailscaleServe(3000, exec as never)).rejects.toThrow("boom");
@@ -175,7 +181,6 @@ describe("tailscale helpers", () => {
   });
 
   it("enableTailscaleServe rethrows original error if sudo fails", async () => {
-    vi.spyOn(tailscale, "getTailscaleBinary").mockResolvedValue("tailscale");
     const originalError = Object.assign(new Error("permission denied"), {
       stderr: "permission denied",
     });

src/infra/tailscale.ts

@@ -150,6 +150,11 @@ export async function getTailnetHostname(exec: typeof runExec = runExec, detecte
 let cachedTailscaleBinary: string | null = null;
 
 export async function getTailscaleBinary(): Promise<string> {
+  const forcedBinary = process.env.OPENCLAW_TEST_TAILSCALE_BINARY?.trim();
+  if (forcedBinary) {
+    cachedTailscaleBinary = forcedBinary;
+    return forcedBinary;
+  }
   if (cachedTailscaleBinary) {
     return cachedTailscaleBinary;
   }

src/infra/transport-ready.test.ts

@@ -1,11 +1,19 @@
-import { describe, expect, it, vi } from "vitest";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { waitForTransportReady } from "./transport-ready.js";
 
 describe("waitForTransportReady", () => {
+  beforeEach(() => {
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
   it("returns when the check succeeds and logs after the delay", async () => {
     const runtime = { log: vi.fn(), error: vi.fn(), exit: vi.fn() };
     let attempts = 0;
-    await waitForTransportReady({
+    const readyPromise = waitForTransportReady({
       label: "test transport",
       timeoutMs: 500,
       logAfterMs: 120,
@@ -20,22 +28,28 @@ describe("waitForTransportReady", () => {
         return { ok: false, error: "not ready" };
       },
     });
+
+    for (let i = 0; i < 5; i += 1) {
+      await vi.advanceTimersByTimeAsync(80);
+    }
+
+    await readyPromise;
     expect(runtime.error).toHaveBeenCalled();
   });
 
   it("throws after the timeout", async () => {
     const runtime = { log: vi.fn(), error: vi.fn(), exit: vi.fn() };
-    await expect(
-      waitForTransportReady({
-        label: "test transport",
-        timeoutMs: 200,
-        logAfterMs: 0,
-        logIntervalMs: 100,
-        pollIntervalMs: 50,
-        runtime,
-        check: async () => ({ ok: false, error: "still down" }),
-      }),
-    ).rejects.toThrow("test transport not ready");
+    const waitPromise = waitForTransportReady({
+      label: "test transport",
+      timeoutMs: 200,
+      logAfterMs: 0,
+      logIntervalMs: 100,
+      pollIntervalMs: 50,
+      runtime,
+      check: async () => ({ ok: false, error: "still down" }),
+    });
+    await vi.advanceTimersByTimeAsync(250);
+    await expect(waitPromise).rejects.toThrow("test transport not ready");
     expect(runtime.error).toHaveBeenCalled();
   });