@getjack/jack 0.1.4 → 0.1.5

package/src/lib/project-link.test.ts

@@ -0,0 +1,459 @@
+/**
+ * Unit tests for project-link.ts
+ *
+ * Tests the .jack/project.json linking system.
+ */
+
+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 {
+	ensureGitignored,
+	generateByoProjectId,
+	getDeployMode,
+	getJackDir,
+	getProjectId,
+	getProjectLinkPath,
+	getTemplatePath,
+	isLinked,
+	linkProject,
+	readProjectLink,
+	readTemplateMetadata,
+	unlinkProject,
+	updateProjectLink,
+	writeTemplateMetadata,
+} from "./project-link.ts";
+
+let testDir: string;
+
+/**
+ * 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-link-test-${timestamp}-${random}`);
+	await mkdir(dir, { recursive: true });
+	return dir;
+}
+
+describe("project-link", () => {
+	beforeEach(async () => {
+		testDir = await createTestDir();
+	});
+
+	afterEach(async () => {
+		await rm(testDir, { recursive: true, force: true });
+	});
+
+	describe("path helpers", () => {
+		it("getJackDir returns correct path", () => {
+			const jackDir = getJackDir(testDir);
+			expect(jackDir).toBe(join(testDir, ".jack"));
+		});
+
+		it("getProjectLinkPath returns correct path", () => {
+			const linkPath = getProjectLinkPath(testDir);
+			expect(linkPath).toBe(join(testDir, ".jack", "project.json"));
+		});
+
+		it("getTemplatePath returns correct path", () => {
+			const templatePath = getTemplatePath(testDir);
+			expect(templatePath).toBe(join(testDir, ".jack", "template.json"));
+		});
+	});
+
+	describe("generateByoProjectId", () => {
+		it("generates unique IDs", () => {
+			const id1 = generateByoProjectId();
+			const id2 = generateByoProjectId();
+
+			expect(id1).not.toBe(id2);
+		});
+
+		it("generates IDs with byo_ prefix", () => {
+			const id = generateByoProjectId();
+			expect(id.startsWith("byo_")).toBe(true);
+		});
+
+		it("generates valid format", () => {
+			const id = generateByoProjectId();
+			// Format: byo_<uuid-like>
+			expect(id.length).toBeGreaterThan(10);
+			expect(id).toMatch(/^byo_[a-f0-9-]+$/);
+		});
+	});
+
+	describe("linkProject", () => {
+		it("creates .jack directory and project.json", async () => {
+			await linkProject(testDir, "proj_abc123", "managed");
+
+			const jackDir = getJackDir(testDir);
+			const linkPath = getProjectLinkPath(testDir);
+
+			expect(existsSync(jackDir)).toBe(true);
+			expect(existsSync(linkPath)).toBe(true);
+		});
+
+		it("writes correct managed project data", async () => {
+			await linkProject(testDir, "proj_abc123", "managed");
+
+			const link = await readProjectLink(testDir);
+
+			expect(link).not.toBeNull();
+			expect(link?.version).toBe(1);
+			expect(link?.project_id).toBe("proj_abc123");
+			expect(link?.deploy_mode).toBe("managed");
+			expect(link?.linked_at).toBeDefined();
+		});
+
+		it("writes correct BYO project data", async () => {
+			const byoId = generateByoProjectId();
+			await linkProject(testDir, byoId, "byo");
+
+			const link = await readProjectLink(testDir);
+
+			expect(link).not.toBeNull();
+			expect(link?.version).toBe(1);
+			expect(link?.project_id).toBe(byoId);
+			expect(link?.deploy_mode).toBe("byo");
+		});
+
+		it("overwrites existing link", async () => {
+			await linkProject(testDir, "proj_old", "managed");
+			await linkProject(testDir, "proj_new", "byo");
+
+			const link = await readProjectLink(testDir);
+
+			expect(link?.project_id).toBe("proj_new");
+			expect(link?.deploy_mode).toBe("byo");
+		});
+
+		it("auto-adds .jack/ to .gitignore", async () => {
+			await linkProject(testDir, "proj_abc123", "managed");
+
+			const gitignorePath = join(testDir, ".gitignore");
+			expect(existsSync(gitignorePath)).toBe(true);
+
+			const content = await readFile(gitignorePath, "utf-8");
+			expect(content).toContain(".jack/");
+		});
+	});
+
+	describe("unlinkProject", () => {
+		it("removes .jack directory", async () => {
+			await linkProject(testDir, "proj_abc123", "managed");
+			expect(existsSync(getJackDir(testDir))).toBe(true);
+
+			await unlinkProject(testDir);
+			expect(existsSync(getJackDir(testDir))).toBe(false);
+		});
+
+		it("handles non-existent .jack directory gracefully", async () => {
+			// Should not throw
+			await unlinkProject(testDir);
+			expect(existsSync(getJackDir(testDir))).toBe(false);
+		});
+
+		it("removes template.json along with project.json", async () => {
+			await linkProject(testDir, "proj_abc123", "managed");
+			await writeTemplateMetadata(testDir, { type: "builtin", name: "miniapp" });
+
+			expect(existsSync(getTemplatePath(testDir))).toBe(true);
+
+			await unlinkProject(testDir);
+			expect(existsSync(getTemplatePath(testDir))).toBe(false);
+		});
+	});
+
+	describe("readProjectLink", () => {
+		it("returns null for non-existent directory", async () => {
+			const link = await readProjectLink(join(testDir, "nonexistent"));
+			expect(link).toBeNull();
+		});
+
+		it("returns null for directory without .jack", async () => {
+			const link = await readProjectLink(testDir);
+			expect(link).toBeNull();
+		});
+
+		it("returns null for invalid JSON", async () => {
+			const jackDir = getJackDir(testDir);
+			await mkdir(jackDir, { recursive: true });
+			await writeFile(getProjectLinkPath(testDir), "{ invalid json");
+
+			const link = await readProjectLink(testDir);
+			expect(link).toBeNull();
+		});
+
+		it("returns null for missing required fields", async () => {
+			const jackDir = getJackDir(testDir);
+			await mkdir(jackDir, { recursive: true });
+			await writeFile(getProjectLinkPath(testDir), JSON.stringify({ version: 1 }));
+
+			const link = await readProjectLink(testDir);
+			expect(link).toBeNull();
+		});
+
+		it("returns valid link data", async () => {
+			await linkProject(testDir, "proj_abc123", "managed");
+
+			const link = await readProjectLink(testDir);
+
+			expect(link).not.toBeNull();
+			expect(link?.project_id).toBe("proj_abc123");
+		});
+	});
+
+	describe("isLinked", () => {
+		it("returns false for unlinked directory", async () => {
+			const linked = await isLinked(testDir);
+			expect(linked).toBe(false);
+		});
+
+		it("returns true for linked directory", async () => {
+			await linkProject(testDir, "proj_abc123", "managed");
+
+			const linked = await isLinked(testDir);
+			expect(linked).toBe(true);
+		});
+
+		it("returns false for corrupted link", async () => {
+			const jackDir = getJackDir(testDir);
+			await mkdir(jackDir, { recursive: true });
+			await writeFile(getProjectLinkPath(testDir), "not json");
+
+			const linked = await isLinked(testDir);
+			expect(linked).toBe(false);
+		});
+	});
+
+	describe("getProjectId", () => {
+		it("returns null for unlinked directory", async () => {
+			const id = await getProjectId(testDir);
+			expect(id).toBeNull();
+		});
+
+		it("returns project ID for linked directory", async () => {
+			await linkProject(testDir, "proj_xyz789", "managed");
+
+			const id = await getProjectId(testDir);
+			expect(id).toBe("proj_xyz789");
+		});
+	});
+
+	describe("getDeployMode", () => {
+		it("returns 'byo' for unlinked directory (default)", async () => {
+			const mode = await getDeployMode(testDir);
+			expect(mode).toBe("byo");
+		});
+
+		it("returns 'managed' for managed project", async () => {
+			await linkProject(testDir, "proj_abc123", "managed");
+
+			const mode = await getDeployMode(testDir);
+			expect(mode).toBe("managed");
+		});
+
+		it("returns 'byo' for BYO project", async () => {
+			await linkProject(testDir, "byo_123", "byo");
+
+			const mode = await getDeployMode(testDir);
+			expect(mode).toBe("byo");
+		});
+	});
+
+	describe("ensureGitignored", () => {
+		it("creates .gitignore if not exists", async () => {
+			await ensureGitignored(testDir);
+
+			const gitignorePath = join(testDir, ".gitignore");
+			expect(existsSync(gitignorePath)).toBe(true);
+
+			const content = await readFile(gitignorePath, "utf-8");
+			expect(content).toContain(".jack/");
+			expect(content).toContain("# Jack project link");
+		});
+
+		it("appends to existing .gitignore", async () => {
+			const gitignorePath = join(testDir, ".gitignore");
+			await writeFile(gitignorePath, "node_modules/\n");
+
+			await ensureGitignored(testDir);
+
+			const content = await readFile(gitignorePath, "utf-8");
+			expect(content).toContain("node_modules/");
+			expect(content).toContain(".jack/");
+		});
+
+		it("does not duplicate .jack/ entry", async () => {
+			await ensureGitignored(testDir);
+			await ensureGitignored(testDir); // Call twice
+
+			const gitignorePath = join(testDir, ".gitignore");
+			const content = await readFile(gitignorePath, "utf-8");
+
+			// Count occurrences of .jack/
+			const matches = content.match(/\.jack\//g) || [];
+			expect(matches.length).toBe(1);
+		});
+
+		it("recognizes .jack without trailing slash", async () => {
+			const gitignorePath = join(testDir, ".gitignore");
+			await writeFile(gitignorePath, ".jack\n");
+
+			await ensureGitignored(testDir);
+
+			const content = await readFile(gitignorePath, "utf-8");
+			// Should not add another entry since .jack is present
+			const matches = content.match(/\.jack/g) || [];
+			expect(matches.length).toBe(1);
+		});
+
+		it("handles .gitignore without trailing newline", async () => {
+			const gitignorePath = join(testDir, ".gitignore");
+			await writeFile(gitignorePath, "node_modules/"); // No trailing newline
+
+			await ensureGitignored(testDir);
+
+			const content = await readFile(gitignorePath, "utf-8");
+			expect(content).toContain("node_modules/");
+			expect(content).toContain(".jack/");
+		});
+	});
+
+	describe("writeTemplateMetadata", () => {
+		it("creates template.json for builtin template", async () => {
+			await writeTemplateMetadata(testDir, { type: "builtin", name: "miniapp" });
+
+			const templatePath = getTemplatePath(testDir);
+			expect(existsSync(templatePath)).toBe(true);
+
+			const template = await readTemplateMetadata(testDir);
+			expect(template).toEqual({ type: "builtin", name: "miniapp" });
+		});
+
+		it("creates template.json for github template", async () => {
+			await writeTemplateMetadata(testDir, {
+				type: "github",
+				name: "user/repo",
+				ref: "main",
+			});
+
+			const template = await readTemplateMetadata(testDir);
+			expect(template).toEqual({ type: "github", name: "user/repo", ref: "main" });
+		});
+
+		it("creates .jack directory if not exists", async () => {
+			await writeTemplateMetadata(testDir, { type: "builtin", name: "api" });
+
+			expect(existsSync(getJackDir(testDir))).toBe(true);
+		});
+	});
+
+	describe("readTemplateMetadata", () => {
+		it("returns null for non-existent template.json", async () => {
+			const template = await readTemplateMetadata(testDir);
+			expect(template).toBeNull();
+		});
+
+		it("returns null for invalid JSON", async () => {
+			await mkdir(getJackDir(testDir), { recursive: true });
+			await writeFile(getTemplatePath(testDir), "not json");
+
+			const template = await readTemplateMetadata(testDir);
+			expect(template).toBeNull();
+		});
+
+		it("returns null for missing required fields", async () => {
+			await mkdir(getJackDir(testDir), { recursive: true });
+			await writeFile(getTemplatePath(testDir), JSON.stringify({ type: "builtin" }));
+
+			const template = await readTemplateMetadata(testDir);
+			expect(template).toBeNull();
+		});
+
+		it("returns valid template data", async () => {
+			await writeTemplateMetadata(testDir, { type: "builtin", name: "hello" });
+
+			const template = await readTemplateMetadata(testDir);
+			expect(template).toEqual({ type: "builtin", name: "hello" });
+		});
+	});
+
+	describe("updateProjectLink", () => {
+		it("updates existing link", async () => {
+			await linkProject(testDir, "proj_abc123", "managed");
+
+			// Get original linked_at
+			const original = await readProjectLink(testDir);
+			expect(original).not.toBeNull();
+
+			// Update with new linked_at
+			await updateProjectLink(testDir, { linked_at: "2024-01-01T00:00:00.000Z" });
+
+			const updated = await readProjectLink(testDir);
+			expect(updated?.project_id).toBe("proj_abc123"); // Unchanged
+			expect(updated?.deploy_mode).toBe("managed"); // Unchanged
+			expect(updated?.linked_at).toBe("2024-01-01T00:00:00.000Z"); // Updated
+		});
+
+		it("throws error for unlinked directory", async () => {
+			await expect(
+				updateProjectLink(testDir, { linked_at: "2024-01-01T00:00:00.000Z" }),
+			).rejects.toThrow("Project is not linked");
+		});
+
+		it("can update project_id", async () => {
+			await linkProject(testDir, "proj_old", "managed");
+			await updateProjectLink(testDir, { project_id: "proj_new" });
+
+			const link = await readProjectLink(testDir);
+			expect(link?.project_id).toBe("proj_new");
+		});
+
+		it("can update deploy_mode", async () => {
+			await linkProject(testDir, "proj_abc123", "managed");
+			await updateProjectLink(testDir, { deploy_mode: "byo" });
+
+			const link = await readProjectLink(testDir);
+			expect(link?.deploy_mode).toBe("byo");
+		});
+	});
+
+	describe("edge cases", () => {
+		it("handles paths with spaces", async () => {
+			const spacePath = join(testDir, "path with spaces");
+			await mkdir(spacePath, { recursive: true });
+
+			await linkProject(spacePath, "proj_spaces", "managed");
+
+			const linked = await isLinked(spacePath);
+			expect(linked).toBe(true);
+		});
+
+		it("handles nested directories", async () => {
+			const nestedPath = join(testDir, "a", "b", "c", "project");
+			await mkdir(nestedPath, { recursive: true });
+
+			await linkProject(nestedPath, "proj_nested", "managed");
+
+			const link = await readProjectLink(nestedPath);
+			expect(link?.project_id).toBe("proj_nested");
+		});
+
+		it("preserves ISO date format in linked_at", async () => {
+			await linkProject(testDir, "proj_abc123", "managed");
+
+			const link = await readProjectLink(testDir);
+			expect(link).not.toBeNull();
+			// Should be valid ISO 8601 date
+			if (link) {
+				expect(new Date(link.linked_at).toISOString()).toBe(link.linked_at);
+			}
+		});
+	});
+});