claude-yes 1.31.2 → 1.32.2

package/ts/runningLock.spec.ts

@@ -1,9 +1,8 @@
-import { execSync } from 'child_process';
-import { existsSync } from 'fs';
-import { mkdir, readFile, rm, writeFile } from 'fs/promises';
-import { homedir } from 'os';
-import path from 'path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { execSync } from "child_process";
+import { existsSync } from "fs";
+import { mkdir, readFile, rm, writeFile } from "fs/promises";
+import path from "path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
 import {
   acquireLock,
   cleanStaleLocks,
@@ -11,13 +10,16 @@ import {
   shouldUseLock,
   type Task,
   updateCurrentTaskStatus,
-} from './runningLock';
+} from "./runningLock";
 
-const LOCK_DIR = path.join(homedir(), '.claude-yes');
-const LOCK_FILE = path.join(LOCK_DIR, 'running.lock.json');
-const TEST_DIR = path.join(process.cwd(), '.cache', 'test-lock');
+// Keep lock files inside the repo to avoid $HOME permission issues in CI
+process.env.CLAUDE_YES_HOME = path.join(process.cwd(), ".cache");
 
-describe('runningLock', () => {
+const LOCK_DIR = path.join(process.env.CLAUDE_YES_HOME, ".claude-yes");
+const LOCK_FILE = path.join(LOCK_DIR, "running.lock.json");
+const TEST_DIR = path.join(process.cwd(), ".cache", "test-lock");
+
+describe("runningLock", () => {
   beforeEach(async () => {
     // Clean up before each test
     await cleanupLockFile();
@@ -30,25 +32,25 @@ describe('runningLock', () => {
     await rm(TEST_DIR, { recursive: true, force: true });
   });
 
-  describe('shouldUseLock', () => {
-    it('should return true for any directory', () => {
+  describe("shouldUseLock", () => {
+    it("should return true for any directory", () => {
       expect(shouldUseLock(process.cwd())).toBe(true);
-      expect(shouldUseLock('/tmp')).toBe(true);
+      expect(shouldUseLock("/tmp")).toBe(true);
       expect(shouldUseLock(TEST_DIR)).toBe(true);
     });
   });
 
-  describe('acquireLock and releaseLock', () => {
-    it('should acquire and release lock successfully', async () => {
-      await acquireLock(TEST_DIR, 'Test task');
+  describe("acquireLock and releaseLock", () => {
+    it("should acquire and release lock successfully", async () => {
+      await acquireLock(TEST_DIR, "Test task");
 
       // Check lock file exists and contains task
       const lockData = await readLockFile();
       expect(lockData.tasks).toHaveLength(1);
       expect(lockData.tasks[0].cwd).toBe(path.resolve(TEST_DIR));
-      expect(lockData.tasks[0].task).toBe('Test task');
+      expect(lockData.tasks[0].task).toBe("Test task");
       expect(lockData.tasks[0].pid).toBe(process.pid);
-      expect(lockData.tasks[0].status).toBe('running');
+      expect(lockData.tasks[0].status).toBe("running");
 
       // Release lock
       await releaseLock();
@@ -58,11 +60,11 @@ describe('runningLock', () => {
       expect(lockDataAfter.tasks).toHaveLength(0);
     });
 
-    it('should create lock directory if it does not exist', async () => {
+    it("should create lock directory if it does not exist", async () => {
       // Remove lock directory
       await rm(LOCK_DIR, { recursive: true, force: true });
 
-      await acquireLock(TEST_DIR, 'Test task');
+      await acquireLock(TEST_DIR, "Test task");
 
       // Check directory and file exist
       expect(existsSync(LOCK_DIR)).toBe(true);
@@ -71,21 +73,21 @@ describe('runningLock', () => {
       await releaseLock();
     });
 
-    it('should handle prompt longer than 100 characters', async () => {
-      const longPrompt = 'A'.repeat(150);
+    it("should handle prompt longer than 100 characters", async () => {
+      const longPrompt = "A".repeat(150);
 
       await acquireLock(TEST_DIR, longPrompt);
 
       const lockData = await readLockFile();
       expect(lockData.tasks[0].task).toHaveLength(100);
-      expect(lockData.tasks[0].task).toBe('A'.repeat(100));
+      expect(lockData.tasks[0].task).toBe("A".repeat(100));
 
       await releaseLock();
     });
 
-    it('should include timestamp fields', async () => {
+    it("should include timestamp fields", async () => {
       const before = Date.now();
-      await acquireLock(TEST_DIR, 'Test task');
+      await acquireLock(TEST_DIR, "Test task");
       const after = Date.now();
 
       const lockData = await readLockFile();
@@ -100,15 +102,15 @@ describe('runningLock', () => {
     });
   });
 
-  describe('git repository detection', () => {
-    it('should detect git root for repository', async () => {
+  describe("git repository detection", () => {
+    it("should detect git root for repository", async () => {
       // Use current directory which is a git repo
-      const gitRoot = execSync('git rev-parse --show-toplevel', {
+      const gitRoot = execSync("git rev-parse --show-toplevel", {
         cwd: process.cwd(),
-        encoding: 'utf8',
+        encoding: "utf8",
       }).trim();
 
-      await acquireLock(process.cwd(), 'Git repo task');
+      await acquireLock(process.cwd(), "Git repo task");
 
       const lockData = await readLockFile();
       expect(lockData.tasks[0].gitRoot).toBe(gitRoot);
@@ -116,14 +118,14 @@ describe('runningLock', () => {
       await releaseLock();
     });
 
-    it('should detect same git root for subdirectory', async () => {
-      const gitRoot = execSync('git rev-parse --show-toplevel', {
+    it("should detect same git root for subdirectory", async () => {
+      const gitRoot = execSync("git rev-parse --show-toplevel", {
         cwd: process.cwd(),
-        encoding: 'utf8',
+        encoding: "utf8",
       }).trim();
-      const subdir = path.join(process.cwd(), 'docs');
+      const subdir = path.join(process.cwd(), "docs");
 
-      await acquireLock(subdir, 'Subdirectory task');
+      await acquireLock(subdir, "Subdirectory task");
 
       const lockData = await readLockFile();
       expect(lockData.tasks[0].gitRoot).toBe(gitRoot);
@@ -132,13 +134,13 @@ describe('runningLock', () => {
       await releaseLock();
     });
 
-    it('should not have gitRoot for non-git directory', async () => {
+    it("should not have gitRoot for non-git directory", async () => {
       // Create a temporary directory outside of any git repo
-      const tempDir = path.join('/tmp', 'test-non-git-' + Date.now());
+      const tempDir = path.join("/tmp", "test-non-git-" + Date.now());
       await mkdir(tempDir, { recursive: true });
 
       try {
-        await acquireLock(tempDir, 'Non-git task');
+        await acquireLock(tempDir, "Non-git task");
 
         const lockData = await readLockFile();
         expect(lockData.tasks[0].gitRoot).toBeUndefined();
@@ -151,35 +153,35 @@ describe('runningLock', () => {
     });
   });
 
-  describe('updateCurrentTaskStatus', () => {
-    it('should update task status', async () => {
-      await acquireLock(TEST_DIR, 'Test task');
+  describe("updateCurrentTaskStatus", () => {
+    it("should update task status", async () => {
+      await acquireLock(TEST_DIR, "Test task");
 
       // Update to completed
-      await updateCurrentTaskStatus('completed');
+      await updateCurrentTaskStatus("completed");
 
       let lockData = await readLockFile();
-      expect(lockData.tasks[0].status).toBe('completed');
+      expect(lockData.tasks[0].status).toBe("completed");
 
       // Update to failed
-      await updateCurrentTaskStatus('failed');
+      await updateCurrentTaskStatus("failed");
 
       lockData = await readLockFile();
-      expect(lockData.tasks[0].status).toBe('failed');
+      expect(lockData.tasks[0].status).toBe("failed");
 
       await releaseLock();
     });
 
-    it('should not throw when updating non-existent task', async () => {
+    it("should not throw when updating non-existent task", async () => {
       // Should complete without throwing
-      await updateCurrentTaskStatus('completed');
+      await updateCurrentTaskStatus("completed");
       // If we got here, no error was thrown
       expect(true).toBe(true);
     });
   });
 
-  describe('cleanStaleLocks', () => {
-    it('should remove stale locks with invalid PIDs', async () => {
+  describe("cleanStaleLocks", () => {
+    it("should remove stale locks with invalid PIDs", async () => {
       // Use a PID that definitely doesn't exist
       const invalidPid = 9999999;
 
@@ -188,9 +190,9 @@ describe('runningLock', () => {
         tasks: [
           {
             cwd: TEST_DIR,
-            task: 'Stale task',
+            task: "Stale task",
             pid: invalidPid,
-            status: 'running' as const,
+            status: "running" as const,
             startedAt: Date.now() - 60000,
             lockedAt: Date.now() - 60000,
           },
@@ -201,25 +203,25 @@ describe('runningLock', () => {
       await writeFile(LOCK_FILE, JSON.stringify(staleLock, null, 2));
 
       // Verify the stale lock was written
-      let rawContent = await readFile(LOCK_FILE, 'utf8');
+      let rawContent = await readFile(LOCK_FILE, "utf8");
       let rawData = JSON.parse(rawContent);
       expect(rawData.tasks).toHaveLength(1);
       expect(rawData.tasks[0].pid).toBe(invalidPid);
 
       // Now acquire a lock - this will trigger cleanup of stale locks
-      await acquireLock(TEST_DIR, 'New task');
+      await acquireLock(TEST_DIR, "New task");
 
       // The stale lock should be cleaned, and only our new task should remain
       const lockData = await readLockFile();
       expect(lockData.tasks).toHaveLength(1);
       expect(lockData.tasks[0].pid).toBe(process.pid);
-      expect(lockData.tasks[0].task).toBe('New task');
+      expect(lockData.tasks[0].task).toBe("New task");
 
       await releaseLock();
     });
 
-    it('should keep valid locks with running PIDs', async () => {
-      await acquireLock(TEST_DIR, 'Valid task');
+    it("should keep valid locks with running PIDs", async () => {
+      await acquireLock(TEST_DIR, "Valid task");
 
       // Clean stale locks (should not remove our lock)
       await cleanStaleLocks();
@@ -231,10 +233,10 @@ describe('runningLock', () => {
       await releaseLock();
     });
 
-    it('should handle corrupted lock file', async () => {
+    it("should handle corrupted lock file", async () => {
       // Write invalid JSON
       await mkdir(LOCK_DIR, { recursive: true });
-      await writeFile(LOCK_FILE, 'invalid json{{{');
+      await writeFile(LOCK_FILE, "invalid json{{{");
 
       // Reading the lock file should handle corruption gracefully
       const lockData = await readLockFile();
@@ -243,7 +245,7 @@ describe('runningLock', () => {
       expect(lockData.tasks).toHaveLength(0);
     });
 
-    it('should handle missing lock file', async () => {
+    it("should handle missing lock file", async () => {
       await rm(LOCK_FILE, { force: true });
 
       // Reading non-existent lock file should return empty
@@ -252,23 +254,23 @@ describe('runningLock', () => {
     });
   });
 
-  describe('concurrent access', () => {
-    it('should handle multiple tasks from different processes', async () => {
+  describe("concurrent access", () => {
+    it("should handle multiple tasks from different processes", async () => {
       // Acquire first task
-      await acquireLock(TEST_DIR, 'Task 1');
+      await acquireLock(TEST_DIR, "Task 1");
 
       // Verify the task exists
       let lockData = await readLockFile();
       expect(lockData.tasks).toHaveLength(1);
-      expect(lockData.tasks[0].task).toBe('Task 1');
+      expect(lockData.tasks[0].task).toBe("Task 1");
 
       // Acquire a second task with the same PID (should replace the first)
-      await acquireLock('/tmp', 'Task 2');
+      await acquireLock("/tmp", "Task 2");
 
       // Should have only one task (the latest one)
       lockData = await readLockFile();
       expect(lockData.tasks).toHaveLength(1);
-      expect(lockData.tasks[0].task).toBe('Task 2');
+      expect(lockData.tasks[0].task).toBe("Task 2");
 
       await releaseLock();
 
@@ -277,52 +279,47 @@ describe('runningLock', () => {
       expect(finalLockData.tasks).toHaveLength(0);
     });
 
-    it('should not duplicate tasks with same PID', async () => {
-      await acquireLock(TEST_DIR, 'Task 1');
+    it("should not duplicate tasks with same PID", async () => {
+      await acquireLock(TEST_DIR, "Task 1");
 
       // Try to acquire again with same PID
-      await acquireLock(TEST_DIR, 'Task 2');
+      await acquireLock(TEST_DIR, "Task 2");
 
       // Should only have one task
       const lockData = await readLockFile();
       expect(lockData.tasks).toHaveLength(1);
-      expect(lockData.tasks[0].task).toBe('Task 2'); // Latest task
+      expect(lockData.tasks[0].task).toBe("Task 2"); // Latest task
 
       await releaseLock();
     });
   });
 
-  describe('lock file structure', () => {
-    it('should have all required fields', async () => {
-      await acquireLock(TEST_DIR, 'Complete task');
+  describe("lock file structure", () => {
+    it("should have all required fields", async () => {
+      await acquireLock(TEST_DIR, "Complete task");
 
       const lockData = await readLockFile();
       const task = lockData.tasks[0];
 
-      expect(task).toHaveProperty('cwd');
-      expect(task).toHaveProperty('task');
-      expect(task).toHaveProperty('pid');
-      expect(task).toHaveProperty('status');
-      expect(task).toHaveProperty('startedAt');
-      expect(task).toHaveProperty('lockedAt');
+      expect(task).toHaveProperty("cwd");
+      expect(task).toHaveProperty("task");
+      expect(task).toHaveProperty("pid");
+      expect(task).toHaveProperty("status");
+      expect(task).toHaveProperty("startedAt");
+      expect(task).toHaveProperty("lockedAt");
 
-      expect(typeof task.cwd).toBe('string');
-      expect(typeof task.task).toBe('string');
-      expect(typeof task.pid).toBe('number');
-      expect(typeof task.status).toBe('string');
-      expect(typeof task.startedAt).toBe('number');
-      expect(typeof task.lockedAt).toBe('number');
+      expect(typeof task.cwd).toBe("string");
+      expect(typeof task.task).toBe("string");
+      expect(typeof task.pid).toBe("number");
+      expect(typeof task.status).toBe("string");
+      expect(typeof task.startedAt).toBe("number");
+      expect(typeof task.lockedAt).toBe("number");
 
       await releaseLock();
     });
 
-    it('should have valid status values', async () => {
-      const validStatuses: Task['status'][] = [
-        'running',
-        'queued',
-        'completed',
-        'failed',
-      ];
+    it("should have valid status values", async () => {
+      const validStatuses: Task["status"][] = ["running", "queued", "completed", "failed"];
 
       for (const status of validStatuses) {
         await acquireLock(TEST_DIR, `Task with ${status}`);
@@ -336,30 +333,29 @@ describe('runningLock', () => {
     });
   });
 
-  describe('edge cases', () => {
-    it('should handle empty task description', async () => {
-      await acquireLock(TEST_DIR, '');
+  describe("edge cases", () => {
+    it("should handle empty task description", async () => {
+      await acquireLock(TEST_DIR, "");
 
       const lockData = await readLockFile();
-      expect(lockData.tasks[0].task).toBe('');
+      expect(lockData.tasks[0].task).toBe("");
 
       await releaseLock();
     });
 
-    it('should handle special characters in task description', async () => {
-      const specialTask =
-        'Task with "quotes" and \'apostrophes\' and \n newlines';
+    it("should handle special characters in task description", async () => {
+      const specialTask = "Task with \"quotes\" and 'apostrophes' and \n newlines";
 
       await acquireLock(TEST_DIR, specialTask);
 
       const lockData = await readLockFile();
-      expect(lockData.tasks[0].task).toContain('quotes');
+      expect(lockData.tasks[0].task).toContain("quotes");
 
       await releaseLock();
     });
 
-    it('should resolve symlinks to real paths', async () => {
-      await acquireLock(TEST_DIR, 'Symlink test');
+    it("should resolve symlinks to real paths", async () => {
+      await acquireLock(TEST_DIR, "Symlink test");
 
       const lockData = await readLockFile();
       // Should be an absolute path
@@ -368,7 +364,7 @@ describe('runningLock', () => {
       await releaseLock();
     });
 
-    it('should handle rapid acquire/release cycles', async () => {
+    it("should handle rapid acquire/release cycles", async () => {
       for (let i = 0; i < 10; i++) {
         await acquireLock(TEST_DIR, `Rapid task ${i}`);
         await releaseLock();
@@ -380,24 +376,24 @@ describe('runningLock', () => {
     });
   });
 
-  describe('queueing behavior', () => {
-    it('should detect when lock is held by same git repo', async () => {
-      const gitRoot = execSync('git rev-parse --show-toplevel', {
+  describe("queueing behavior", () => {
+    it("should detect when lock is held by same git repo", async () => {
+      const gitRoot = execSync("git rev-parse --show-toplevel", {
         cwd: process.cwd(),
-        encoding: 'utf8',
+        encoding: "utf8",
       }).trim();
 
       // Acquire lock at root
-      await acquireLock(gitRoot, 'Root task');
+      await acquireLock(gitRoot, "Root task");
 
       // Create a lock with different PID to simulate another process
       const lockData = await readLockFile();
       lockData.tasks.push({
-        cwd: path.join(gitRoot, 'subdirectory'),
+        cwd: path.join(gitRoot, "subdirectory"),
         gitRoot: gitRoot,
-        task: 'Subdirectory task',
+        task: "Subdirectory task",
         pid: process.pid + 1,
-        status: 'running',
+        status: "running",
         startedAt: Date.now(),
         lockedAt: Date.now(),
       });
@@ -405,15 +401,13 @@ describe('runningLock', () => {
 
       // Both tasks should be in the same git repo
       const updatedLockData = await readLockFile();
-      const gitRoots = updatedLockData.tasks
-        .map((t) => t.gitRoot)
-        .filter((g) => g);
+      const gitRoots = updatedLockData.tasks.map((t) => t.gitRoot).filter((g) => g);
       expect(new Set(gitRoots).size).toBe(1); // All same git root
 
       await releaseLock();
     });
 
-    it('should allow different directories without git repos', async () => {
+    it("should allow different directories without git repos", async () => {
       // Test that when we already have a task, acquiring a new one replaces it
       // (since both use the same PID)
 
@@ -421,10 +415,10 @@ describe('runningLock', () => {
       const lock = {
         tasks: [
           {
-            cwd: '/tmp',
-            task: 'Tmp task',
+            cwd: "/tmp",
+            task: "Tmp task",
             pid: process.pid,
-            status: 'running' as const,
+            status: "running" as const,
             startedAt: Date.now(),
             lockedAt: Date.now(),
           },
@@ -435,27 +429,27 @@ describe('runningLock', () => {
       // Verify initial state
       let lockData = await readLockFile();
       expect(lockData.tasks).toHaveLength(1);
-      expect(lockData.tasks[0].task).toBe('Tmp task');
+      expect(lockData.tasks[0].task).toBe("Tmp task");
 
       // Acquire lock for different directory (should replace the existing task)
-      await acquireLock(TEST_DIR, 'Test task');
+      await acquireLock(TEST_DIR, "Test task");
 
       // Should only have the new task
       lockData = await readLockFile();
       expect(lockData.tasks).toHaveLength(1);
-      expect(lockData.tasks[0].task).toBe('Test task');
+      expect(lockData.tasks[0].task).toBe("Test task");
 
       await releaseLock();
     });
   });
 
-  describe('disableLock option', () => {
-    it('should respect lock file operations when disableLock is false', async () => {
+  describe("disableLock option", () => {
+    it("should respect lock file operations when disableLock is false", async () => {
       // Clean up first
       await rm(LOCK_FILE, { force: true });
 
       // When disableLock is not used (default behavior), locks work normally
-      await acquireLock(TEST_DIR, 'Test task');
+      await acquireLock(TEST_DIR, "Test task");
       expect(existsSync(LOCK_FILE)).toBe(true);
 
       const lockData = await readLockFile();
@@ -481,7 +475,7 @@ async function cleanupLockFile() {
 
 async function readLockFile(): Promise<{ tasks: Task[] }> {
   try {
-    const content = await readFile(LOCK_FILE, 'utf8');
+    const content = await readFile(LOCK_FILE, "utf8");
     const lockFile = JSON.parse(content);
     // Don't clean stale locks in tests - we want to see the raw data
     return lockFile;