test: add LocalRuntime unit tests

Add comprehensive test coverage for LocalRuntime:
- Constructor and getWorkspacePath behavior (ignores args, returns project path)
- createWorkspace success/failure cases
- deleteWorkspace no-op behavior (doesn't delete anything)
- renameWorkspace/forkWorkspace unsupported operation errors
- Inherited LocalBaseRuntime methods (exec, stat, resolvePath, normalizePath)

12 new tests covering the project-dir runtime behavior.

Author: ammar-agent

src/node/runtime/LocalRuntime.test.ts

@@ -0,0 +1,217 @@
+import { describe, expect, it, beforeAll, afterAll } from "bun:test";
+import * as os from "os";
+import * as path from "path";
+import * as fs from "fs/promises";
+import { LocalRuntime } from "./LocalRuntime";
+import type { InitLogger } from "./Runtime";
+
+// Test helper to create a mock init logger
+function createMockLogger(): InitLogger & { steps: string[]; stdout: string[]; stderr: string[] } {
+  const logger = {
+    steps: [] as string[],
+    stdout: [] as string[],
+    stderr: [] as string[],
+    completedWith: null as number | null,
+    logStep(message: string) {
+      logger.steps.push(message);
+    },
+    logStdout(line: string) {
+      logger.stdout.push(line);
+    },
+    logStderr(line: string) {
+      logger.stderr.push(line);
+    },
+    logComplete(exitCode: number) {
+      logger.completedWith = exitCode;
+    },
+  };
+  return logger;
+}
+
+describe("LocalRuntime", () => {
+  // Use a temp directory for tests
+  let testDir: string;
+
+  beforeAll(async () => {
+    testDir = await fs.mkdtemp(path.join(os.tmpdir(), "localruntime-test-"));
+  });
+
+  afterAll(async () => {
+    await fs.rm(testDir, { recursive: true, force: true });
+  });
+
+  describe("constructor and getWorkspacePath", () => {
+    it("stores projectPath and returns it regardless of arguments", () => {
+      const runtime = new LocalRuntime("/home/user/my-project");
+      // Both arguments are ignored - always returns the project path
+      expect(runtime.getWorkspacePath("/other/path", "some-branch")).toBe("/home/user/my-project");
+      expect(runtime.getWorkspacePath("", "")).toBe("/home/user/my-project");
+    });
+
+    it("does not expand tilde (unlike WorktreeRuntime)", () => {
+      // LocalRuntime stores the path as-is; callers must pass expanded paths
+      const runtime = new LocalRuntime("~/my-project");
+      expect(runtime.getWorkspacePath("", "")).toBe("~/my-project");
+    });
+  });
+
+  describe("createWorkspace", () => {
+    it("succeeds when directory exists", async () => {
+      const runtime = new LocalRuntime(testDir);
+      const logger = createMockLogger();
+
+      const result = await runtime.createWorkspace({
+        projectPath: testDir,
+        branchName: "main",
+        trunkBranch: "main",
+        directoryName: "main",
+        initLogger: logger,
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.workspacePath).toBe(testDir);
+      expect(logger.steps.length).toBeGreaterThan(0);
+      expect(logger.steps.some((s) => s.includes("project directory"))).toBe(true);
+    });
+
+    it("fails when directory does not exist", async () => {
+      const nonExistentPath = path.join(testDir, "does-not-exist");
+      const runtime = new LocalRuntime(nonExistentPath);
+      const logger = createMockLogger();
+
+      const result = await runtime.createWorkspace({
+        projectPath: nonExistentPath,
+        branchName: "main",
+        trunkBranch: "main",
+        directoryName: "main",
+        initLogger: logger,
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("does not exist");
+    });
+  });
+
+  describe("deleteWorkspace", () => {
+    it("returns success without deleting anything", async () => {
+      const runtime = new LocalRuntime(testDir);
+
+      // Create a test file to verify it isn't deleted
+      const testFile = path.join(testDir, "delete-test.txt");
+      await fs.writeFile(testFile, "should not be deleted");
+
+      const result = await runtime.deleteWorkspace(testDir, "main", false);
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.deletedPath).toBe(testDir);
+      }
+
+      // Verify file still exists
+      const fileStillExists = await fs.access(testFile).then(
+        () => true,
+        () => false
+      );
+      expect(fileStillExists).toBe(true);
+
+      // Cleanup
+      await fs.unlink(testFile);
+    });
+
+    it("returns success even with force=true (still no-op)", async () => {
+      const runtime = new LocalRuntime(testDir);
+
+      const result = await runtime.deleteWorkspace(testDir, "main", true);
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.deletedPath).toBe(testDir);
+      }
+      // Directory should still exist
+      const dirExists = await fs.access(testDir).then(
+        () => true,
+        () => false
+      );
+      expect(dirExists).toBe(true);
+    });
+  });
+
+  describe("renameWorkspace", () => {
+    it("returns error - operation not supported", async () => {
+      const runtime = new LocalRuntime(testDir);
+
+      const result = await runtime.renameWorkspace(testDir, "old", "new");
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error).toContain("Cannot rename");
+        expect(result.error).toContain("project-dir");
+      }
+    });
+  });
+
+  describe("forkWorkspace", () => {
+    it("returns error - operation not supported", async () => {
+      const runtime = new LocalRuntime(testDir);
+      const logger = createMockLogger();
+
+      const result = await runtime.forkWorkspace({
+        projectPath: testDir,
+        sourceWorkspaceName: "main",
+        newWorkspaceName: "feature",
+        initLogger: logger,
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain("Cannot fork");
+      expect(result.error).toContain("project-dir");
+    });
+  });
+
+  describe("inherited LocalBaseRuntime methods", () => {
+    it("exec runs commands in projectPath", async () => {
+      const runtime = new LocalRuntime(testDir);
+
+      const stream = await runtime.exec("pwd", {
+        cwd: testDir,
+        timeout: 10,
+      });
+
+      const reader = stream.stdout.getReader();
+      let output = "";
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        output += new TextDecoder().decode(value);
+      }
+
+      const exitCode = await stream.exitCode;
+      expect(exitCode).toBe(0);
+      expect(output.trim()).toBe(testDir);
+    });
+
+    it("stat works on projectPath", async () => {
+      const runtime = new LocalRuntime(testDir);
+
+      const stat = await runtime.stat(testDir);
+
+      expect(stat.isDirectory).toBe(true);
+    });
+
+    it("resolvePath expands tilde", async () => {
+      const runtime = new LocalRuntime(testDir);
+
+      const resolved = await runtime.resolvePath("~");
+
+      expect(resolved).toBe(os.homedir());
+    });
+
+    it("normalizePath resolves relative paths", () => {
+      const runtime = new LocalRuntime(testDir);
+
+      const result = runtime.normalizePath(".", testDir);
+
+      expect(result).toBe(testDir);
+    });
+  });
+});