@getjack/jack 0.1.3 → 0.1.5

package/src/lib/paths-index.test.ts

@@ -0,0 +1,546 @@
+/**
+ * Unit tests for paths-index.ts
+ *
+ * Tests the paths index that tracks where projects live locally, keyed by project_id.
+ */
+
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import { existsSync } from "node:fs";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import {
+	type DiscoveredProject,
+	type PathsIndex,
+	findProjectIdByPath,
+	getAllPaths,
+	getIndexPath,
+	getPathsForProject,
+	readPathsIndex,
+	registerDiscoveredProjects,
+	registerPath,
+	scanAndRegisterProjects,
+	unregisterPath,
+	writePathsIndex,
+} from "./paths-index.ts";
+
+import { linkProject } from "./project-link.ts";
+
+let testDir: string;
+let testConfigDir: string;
+let originalPathsIndex: string | null = null;
+
+/**
+ * Create a unique temp directory for each test
+ */
+async function createTestDir(): Promise<string> {
+	const timestamp = Date.now();
+	const random = Math.random().toString(36).substring(7);
+	const dir = join(tmpdir(), `jack-paths-test-${timestamp}-${random}`);
+	await mkdir(dir, { recursive: true });
+	return dir;
+}
+
+/**
+ * Create a mock linked project
+ */
+async function createLinkedProject(
+	parentDir: string,
+	name: string,
+	projectId: string,
+	deployMode: "managed" | "byo" = "managed",
+): Promise<string> {
+	const projectDir = join(parentDir, name);
+	await mkdir(projectDir, { recursive: true });
+	await linkProject(projectDir, projectId, deployMode);
+	return projectDir;
+}
+
+/**
+ * Save the current paths index state for restoration after tests
+ */
+async function savePathsIndex(): Promise<void> {
+	const indexPath = getIndexPath();
+	if (existsSync(indexPath)) {
+		originalPathsIndex = await readFile(indexPath, "utf-8");
+	} else {
+		originalPathsIndex = null;
+	}
+}
+
+/**
+ * Restore the paths index to its original state
+ */
+async function restorePathsIndex(): Promise<void> {
+	const indexPath = getIndexPath();
+	if (originalPathsIndex !== null) {
+		await writeFile(indexPath, originalPathsIndex);
+	} else if (existsSync(indexPath)) {
+		// Clear the index if it didn't exist before
+		await writePathsIndex({ version: 1, paths: {}, updatedAt: "" });
+	}
+}
+
+describe("paths-index", () => {
+	beforeEach(async () => {
+		testDir = await createTestDir();
+		testConfigDir = join(testDir, "config");
+		await mkdir(testConfigDir, { recursive: true });
+		// Save current index state and start fresh
+		await savePathsIndex();
+		await writePathsIndex({ version: 1, paths: {}, updatedAt: "" });
+	});
+
+	afterEach(async () => {
+		await rm(testDir, { recursive: true, force: true });
+		// Restore original index state
+		await restorePathsIndex();
+	});
+
+	describe("PathsIndex structure", () => {
+		it("validates correct structure", () => {
+			const validIndex: PathsIndex = {
+				version: 1,
+				paths: {
+					proj_abc123: ["/path/to/project"],
+					proj_def456: ["/path/to/fork1", "/path/to/fork2"],
+				},
+				updatedAt: "2024-01-15T10:00:00.000Z",
+			};
+
+			expect(validIndex.version).toBe(1);
+			expect(typeof validIndex.paths).toBe("object");
+			expect(Array.isArray(validIndex.paths.proj_abc123)).toBe(true);
+		});
+	});
+
+	describe("readPathsIndex / writePathsIndex", () => {
+		it("returns empty index when file does not exist", async () => {
+			// Note: This test uses the real CONFIG_DIR, but we're testing the pattern
+			const index = await readPathsIndex();
+
+			expect(index.version).toBe(1);
+			expect(typeof index.paths).toBe("object");
+			expect(index.updatedAt).toBeDefined();
+		});
+
+		it("preserves data through write/read cycle", async () => {
+			const testIndex: PathsIndex = {
+				version: 1,
+				paths: {
+					proj_test: ["/test/path"],
+				},
+				updatedAt: "",
+			};
+
+			await writePathsIndex(testIndex);
+			const readBack = await readPathsIndex();
+
+			expect(readBack.paths.proj_test).toContain("/test/path");
+			expect(readBack.updatedAt).toBeDefined();
+		});
+	});
+
+	describe("registerPath", () => {
+		it("registers a new path for a new project", async () => {
+			const projectDir = await createLinkedProject(testDir, "my-project", "proj_abc123");
+
+			await registerPath("proj_abc123", projectDir);
+
+			const index = await readPathsIndex();
+			expect(index.paths.proj_abc123).toContain(projectDir);
+		});
+
+		it("handles duplicate paths (idempotent)", async () => {
+			const projectDir = await createLinkedProject(testDir, "my-project", "proj_abc123");
+
+			await registerPath("proj_abc123", projectDir);
+			await registerPath("proj_abc123", projectDir);
+
+			const index = await readPathsIndex();
+			expect(index.paths.proj_abc123).toHaveLength(1);
+		});
+
+		it("allows multiple paths for the same project", async () => {
+			const path1 = await createLinkedProject(testDir, "project1", "proj_abc123");
+			const path2 = await createLinkedProject(join(testDir, "forks"), "project2", "proj_abc123");
+
+			await registerPath("proj_abc123", path1);
+			await registerPath("proj_abc123", path2);
+
+			const index = await readPathsIndex();
+			expect(index.paths.proj_abc123).toHaveLength(2);
+			expect(index.paths.proj_abc123).toContain(path1);
+			expect(index.paths.proj_abc123).toContain(path2);
+		});
+
+		it("converts relative paths to absolute", async () => {
+			const projectDir = await createLinkedProject(testDir, "rel-project", "proj_rel");
+
+			// Use relative path
+			const originalCwd = process.cwd();
+			process.chdir(testDir);
+
+			try {
+				await registerPath("proj_rel", "rel-project");
+				const index = await readPathsIndex();
+
+				// Should store absolute path
+				expect(index.paths.proj_rel[0].startsWith("/")).toBe(true);
+			} finally {
+				process.chdir(originalCwd);
+			}
+		});
+	});
+
+	describe("unregisterPath", () => {
+		it("removes an existing path", async () => {
+			const projectDir = await createLinkedProject(testDir, "my-project", "proj_abc123");
+
+			await registerPath("proj_abc123", projectDir);
+			await unregisterPath("proj_abc123", projectDir);
+
+			const index = await readPathsIndex();
+			expect(index.paths.proj_abc123).toBeUndefined();
+		});
+
+		it("handles removing non-existent path gracefully", async () => {
+			// Should not throw
+			await unregisterPath("proj_nonexistent", "/some/path");
+
+			const index = await readPathsIndex();
+			expect(index.paths.proj_nonexistent).toBeUndefined();
+		});
+
+		it("keeps other paths when removing one", async () => {
+			const path1 = await createLinkedProject(testDir, "project1", "proj_abc123");
+			const path2 = await createLinkedProject(join(testDir, "forks"), "project2", "proj_abc123");
+
+			await registerPath("proj_abc123", path1);
+			await registerPath("proj_abc123", path2);
+			await unregisterPath("proj_abc123", path1);
+
+			const index = await readPathsIndex();
+			expect(index.paths.proj_abc123).toHaveLength(1);
+			expect(index.paths.proj_abc123).toContain(path2);
+		});
+	});
+
+	describe("getPathsForProject", () => {
+		it("returns empty array for unknown project", async () => {
+			const paths = await getPathsForProject("proj_unknown");
+			expect(paths).toHaveLength(0);
+		});
+
+		it("returns valid paths", async () => {
+			const projectDir = await createLinkedProject(testDir, "my-project", "proj_abc123");
+			await registerPath("proj_abc123", projectDir);
+
+			const paths = await getPathsForProject("proj_abc123");
+			expect(paths).toHaveLength(1);
+			expect(paths).toContain(projectDir);
+		});
+
+		it("prunes paths where .jack/project.json is missing", async () => {
+			const validProject = await createLinkedProject(testDir, "valid", "proj_abc123");
+			const invalidPath = join(testDir, "invalid");
+			await mkdir(invalidPath, { recursive: true });
+			// No .jack/project.json in invalidPath
+
+			// Manually add both to index
+			const index = await readPathsIndex();
+			index.paths.proj_abc123 = [validProject, invalidPath];
+			await writePathsIndex(index);
+
+			const paths = await getPathsForProject("proj_abc123");
+			expect(paths).toHaveLength(1);
+			expect(paths).toContain(validProject);
+			expect(paths).not.toContain(invalidPath);
+		});
+
+		it("prunes paths where project_id does not match", async () => {
+			const path1 = await createLinkedProject(testDir, "project1", "proj_abc123");
+			const path2 = await createLinkedProject(testDir, "project2", "proj_different");
+
+			// Manually add mismatched path to index
+			const index = await readPathsIndex();
+			index.paths.proj_abc123 = [path1, path2]; // path2 has different project_id
+			await writePathsIndex(index);
+
+			const paths = await getPathsForProject("proj_abc123");
+			expect(paths).toHaveLength(1);
+			expect(paths).toContain(path1);
+			expect(paths).not.toContain(path2);
+		});
+
+		it("removes project entry when all paths are invalid", async () => {
+			const invalidPath = join(testDir, "invalid");
+			await mkdir(invalidPath, { recursive: true });
+
+			const index = await readPathsIndex();
+			index.paths.proj_abc123 = [invalidPath];
+			await writePathsIndex(index);
+
+			const paths = await getPathsForProject("proj_abc123");
+			expect(paths).toHaveLength(0);
+
+			const updatedIndex = await readPathsIndex();
+			expect(updatedIndex.paths.proj_abc123).toBeUndefined();
+		});
+	});
+
+	describe("getAllPaths", () => {
+		it("returns empty object when no projects registered", async () => {
+			// Clear any existing paths
+			await writePathsIndex({ version: 1, paths: {}, updatedAt: "" });
+
+			const allPaths = await getAllPaths();
+			expect(Object.keys(allPaths)).toHaveLength(0);
+		});
+
+		it("returns all valid paths for all projects", async () => {
+			const project1 = await createLinkedProject(testDir, "project1", "proj_one");
+			const project2 = await createLinkedProject(testDir, "project2", "proj_two");
+
+			await registerPath("proj_one", project1);
+			await registerPath("proj_two", project2);
+
+			const allPaths = await getAllPaths();
+			expect(allPaths.proj_one).toContain(project1);
+			expect(allPaths.proj_two).toContain(project2);
+		});
+
+		it("prunes invalid paths across all projects", async () => {
+			const validProject = await createLinkedProject(testDir, "valid", "proj_valid");
+			const invalidPath = join(testDir, "invalid");
+			await mkdir(invalidPath, { recursive: true });
+
+			const index = await readPathsIndex();
+			index.paths.proj_valid = [validProject];
+			index.paths.proj_invalid = [invalidPath];
+			await writePathsIndex(index);
+
+			const allPaths = await getAllPaths();
+			expect(allPaths.proj_valid).toBeDefined();
+			expect(allPaths.proj_invalid).toBeUndefined();
+		});
+	});
+
+	describe("scanAndRegisterProjects", () => {
+		it("discovers linked projects", async () => {
+			await createLinkedProject(testDir, "project1", "proj_one", "managed");
+			await createLinkedProject(testDir, "project2", "proj_two", "byo");
+
+			const discovered = await scanAndRegisterProjects(testDir);
+
+			expect(discovered).toHaveLength(2);
+			const ids = discovered.map((p) => p.projectId).sort();
+			expect(ids).toEqual(["proj_one", "proj_two"]);
+		});
+
+		it("ignores directories without .jack/project.json", async () => {
+			await createLinkedProject(testDir, "linked", "proj_linked");
+
+			// Create directory without .jack
+			const unlinkedDir = join(testDir, "unlinked");
+			await mkdir(unlinkedDir, { recursive: true });
+			// Add wrangler.jsonc to simulate old-style project
+			await writeFile(join(unlinkedDir, "wrangler.jsonc"), JSON.stringify({ name: "unlinked" }));
+
+			const discovered = await scanAndRegisterProjects(testDir);
+
+			expect(discovered).toHaveLength(1);
+			expect(discovered[0].projectId).toBe("proj_linked");
+		});
+
+		it("respects maxDepth", async () => {
+			const deepPath = join(testDir, "a", "b", "c", "d");
+			await mkdir(deepPath, { recursive: true });
+			await linkProject(deepPath, "proj_deep", "managed");
+
+			const shallowProject = await createLinkedProject(testDir, "shallow", "proj_shallow");
+
+			// maxDepth=2: 0=testDir, 1=shallow|a, 2=b
+			// Should not find deep project at depth 4
+			const discovered = await scanAndRegisterProjects(testDir, 2);
+
+			expect(discovered).toHaveLength(1);
+			expect(discovered[0].projectId).toBe("proj_shallow");
+		});
+
+		it("skips node_modules", async () => {
+			const nodeModulesProject = join(testDir, "node_modules", "some-package");
+			await mkdir(nodeModulesProject, { recursive: true });
+			await linkProject(nodeModulesProject, "proj_skip", "managed");
+
+			const validProject = await createLinkedProject(testDir, "valid", "proj_valid");
+
+			const discovered = await scanAndRegisterProjects(testDir);
+
+			expect(discovered).toHaveLength(1);
+			expect(discovered[0].projectId).toBe("proj_valid");
+		});
+
+		it("skips .git directory", async () => {
+			const gitProject = join(testDir, ".git", "hooks");
+			await mkdir(gitProject, { recursive: true });
+			await linkProject(gitProject, "proj_git", "managed");
+
+			const validProject = await createLinkedProject(testDir, "valid", "proj_valid");
+
+			const discovered = await scanAndRegisterProjects(testDir);
+
+			expect(discovered).toHaveLength(1);
+			expect(discovered[0].projectId).toBe("proj_valid");
+		});
+
+		it("does not recurse into linked projects", async () => {
+			const parentProject = await createLinkedProject(testDir, "parent", "proj_parent");
+
+			// Create nested project inside parent
+			const nestedDir = join(parentProject, "packages", "child");
+			await mkdir(nestedDir, { recursive: true });
+			await linkProject(nestedDir, "proj_child", "managed");
+
+			const discovered = await scanAndRegisterProjects(testDir);
+
+			// Should only find parent, not nested child
+			expect(discovered).toHaveLength(1);
+			expect(discovered[0].projectId).toBe("proj_parent");
+		});
+
+		it("registers discovered projects in index", async () => {
+			await createLinkedProject(testDir, "project1", "proj_one");
+
+			await scanAndRegisterProjects(testDir);
+
+			const paths = await getPathsForProject("proj_one");
+			expect(paths).toHaveLength(1);
+		});
+
+		it("returns deploy mode info", async () => {
+			await createLinkedProject(testDir, "managed-project", "proj_managed", "managed");
+			await createLinkedProject(testDir, "byo-project", "proj_byo", "byo");
+
+			const discovered = await scanAndRegisterProjects(testDir);
+
+			const managedProject = discovered.find((p) => p.projectId === "proj_managed");
+			const byoProject = discovered.find((p) => p.projectId === "proj_byo");
+
+			expect(managedProject?.deployMode).toBe("managed");
+			expect(byoProject?.deployMode).toBe("byo");
+		});
+	});
+
+	describe("registerDiscoveredProjects", () => {
+		it("registers multiple projects efficiently", async () => {
+			const project1 = await createLinkedProject(testDir, "project1", "proj_one");
+			const project2 = await createLinkedProject(testDir, "project2", "proj_two");
+
+			const discovered: DiscoveredProject[] = [
+				{ projectId: "proj_one", path: project1, deployMode: "managed" },
+				{ projectId: "proj_two", path: project2, deployMode: "byo" },
+			];
+
+			await registerDiscoveredProjects(discovered);
+
+			const index = await readPathsIndex();
+			expect(index.paths.proj_one).toContain(project1);
+			expect(index.paths.proj_two).toContain(project2);
+		});
+
+		it("merges with existing paths", async () => {
+			const existing = await createLinkedProject(testDir, "existing", "proj_one");
+			const newProject = await createLinkedProject(join(testDir, "fork"), "new", "proj_one");
+
+			// Register existing first
+			await registerPath("proj_one", existing);
+
+			// Then bulk register including same project_id
+			await registerDiscoveredProjects([
+				{ projectId: "proj_one", path: newProject, deployMode: "managed" },
+			]);
+
+			const index = await readPathsIndex();
+			expect(index.paths.proj_one).toHaveLength(2);
+			expect(index.paths.proj_one).toContain(existing);
+			expect(index.paths.proj_one).toContain(newProject);
+		});
+	});
+
+	describe("findProjectIdByPath", () => {
+		it("returns null for unregistered path", async () => {
+			const id = await findProjectIdByPath("/some/unknown/path");
+			expect(id).toBeNull();
+		});
+
+		it("returns project ID for registered path", async () => {
+			const projectDir = await createLinkedProject(testDir, "my-project", "proj_abc123");
+			await registerPath("proj_abc123", projectDir);
+
+			const id = await findProjectIdByPath(projectDir);
+			expect(id).toBe("proj_abc123");
+		});
+
+		it("handles relative paths", async () => {
+			const projectDir = await createLinkedProject(testDir, "rel-project", "proj_rel");
+			await registerPath("proj_rel", projectDir);
+
+			// Test that absolute path works (relative path resolution is cwd-dependent)
+			const id = await findProjectIdByPath(projectDir);
+			expect(id).toBe("proj_rel");
+		});
+	});
+
+	describe("getIndexPath", () => {
+		it("returns the index file path", () => {
+			const path = getIndexPath();
+			expect(path).toContain("paths.json");
+			expect(path).toContain(".config");
+			expect(path).toContain("jack");
+		});
+	});
+
+	describe("edge cases", () => {
+		it("handles empty scan directory", async () => {
+			const emptyDir = join(testDir, "empty");
+			await mkdir(emptyDir, { recursive: true });
+
+			const discovered = await scanAndRegisterProjects(emptyDir);
+			expect(discovered).toHaveLength(0);
+		});
+
+		it("handles paths with spaces", async () => {
+			const spacePath = join(testDir, "path with spaces");
+			await createLinkedProject(spacePath, "project", "proj_spaces");
+
+			const discovered = await scanAndRegisterProjects(testDir);
+			expect(discovered).toHaveLength(1);
+			expect(discovered[0].projectId).toBe("proj_spaces");
+		});
+
+		it("handles permission errors gracefully", async () => {
+			// Create accessible project
+			await createLinkedProject(testDir, "accessible", "proj_accessible");
+
+			// Scan should work even if some directories are inaccessible
+			const discovered = await scanAndRegisterProjects(testDir);
+			expect(discovered.some((p) => p.projectId === "proj_accessible")).toBe(true);
+		});
+
+		it("updates updatedAt on write", async () => {
+			const before = new Date().toISOString();
+
+			// Small delay to ensure different timestamp
+			await new Promise((resolve) => setTimeout(resolve, 10));
+
+			await writePathsIndex({ version: 1, paths: {}, updatedAt: "" });
+
+			const index = await readPathsIndex();
+			expect(new Date(index.updatedAt).getTime()).toBeGreaterThanOrEqual(
+				new Date(before).getTime(),
+			);
+		});
+	});
+});