jsdoczoom 0.4.5 → 0.4.11

package/dist/test/barrel.test.js

@@ -0,0 +1,77 @@
+import { dirname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { describe, expect, it } from "vitest";
+import { getBarrelChildren, isBarrel } from "../src/barrel.js";
+
+/**
+ * Verifies that isBarrel correctly identifies index.ts/index.tsx files and
+ * that getBarrelChildren discovers sibling files and child barrels while
+ * respecting .d.ts exclusion and index.ts-over-index.tsx priority.
+ *
+ * @summary Tests for barrel detection and child discovery logic
+ */
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const fixturesDir = resolve(__dirname, "fixtures");
+describe("isBarrel", () => {
+	it("detects index.ts as barrel", () => {
+		expect(isBarrel("/some/path/index.ts")).toBe(true);
+		expect(isBarrel("index.ts")).toBe(true);
+	});
+	it("detects index.tsx as barrel", () => {
+		expect(isBarrel("/some/path/index.tsx")).toBe(true);
+		expect(isBarrel("index.tsx")).toBe(true);
+	});
+	it("non-index files are not barrels", () => {
+		expect(isBarrel("/some/path/helper.ts")).toBe(false);
+		expect(isBarrel("/some/path/index.test.ts")).toBe(false);
+		expect(isBarrel("/some/path/index.d.ts")).toBe(false);
+		expect(isBarrel("/some/path/index.stories.tsx")).toBe(false);
+		expect(isBarrel("/some/path/main.ts")).toBe(false);
+		expect(isBarrel("/some/path/utils.tsx")).toBe(false);
+	});
+});
+describe("getBarrelChildren", () => {
+	it("returns leaf children from barrel directory", () => {
+		const barrelPath = resolve(fixturesDir, "barrel-basic", "index.ts");
+		const children = getBarrelChildren(barrelPath, fixturesDir);
+		const childNames = children.map((c) => c.split("/").pop());
+		expect(childNames).toContain("helper.ts");
+		expect(childNames).toContain("utils.ts");
+		expect(childNames).not.toContain("index.ts");
+	});
+	it("returns child barrel from subdirectory", () => {
+		const barrelPath = resolve(fixturesDir, "barrel-nested", "index.ts");
+		const children = getBarrelChildren(barrelPath, fixturesDir);
+		const childPaths = children.map((c) => c.replace(`${fixturesDir}/`, ""));
+		expect(childPaths).toContain("barrel-nested/leaf.ts");
+		expect(childPaths).toContain("barrel-nested/sub/index.ts");
+		expect(childPaths).not.toContain("barrel-nested/index.ts");
+	});
+	it("index.ts takes priority over index.tsx in same directory", () => {
+		const barrelPath = resolve(
+			fixturesDir,
+			"barrel-ts-tsx-priority",
+			"index.ts",
+		);
+		const children = getBarrelChildren(barrelPath, fixturesDir);
+		const childNames = children.map((c) => c.split("/").pop());
+		// index.tsx should be included as a leaf (sibling, not the barrel)
+		expect(childNames).toContain("index.tsx");
+		expect(childNames).toContain("other.ts");
+		// The barrel itself (index.ts) should not be included
+		expect(childNames).not.toContain("index.ts");
+	});
+	it("barrel with zero children returns empty array", () => {
+		const barrelPath = resolve(fixturesDir, "barrel-zero-children", "index.ts");
+		const children = getBarrelChildren(barrelPath, fixturesDir);
+		expect(children).toEqual([]);
+	});
+	it("excludes .d.ts files", () => {
+		// Use barrel-basic which has no .d.ts files; verify none appear
+		const barrelPath = resolve(fixturesDir, "barrel-basic", "index.ts");
+		const children = getBarrelChildren(barrelPath, fixturesDir);
+		for (const child of children) {
+			expect(child).not.toMatch(/\.d\.ts$/);
+		}
+	});
+});

package/dist/test/cache.test.js

@@ -0,0 +1,222 @@
+/**
+ * Tests for the content-hash-based disk cache module. Verifies content hashing,
+ * cache read/write operations, directory creation, graceful error handling,
+ * concurrency safety, and mode namespacing using temporary test directories.
+ *
+ * @summary Unit and integration tests for cache operations
+ */
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { describe, expect, it, vi } from "vitest";
+import {
+	computeContentHash,
+	ensureCacheDir,
+	processWithCache,
+	readCacheEntry,
+	writeCacheEntry,
+} from "../src/cache.js";
+
+/**
+ * Create a temporary directory, run a callback with it, then clean up.
+ *
+ * @param fn - Callback receiving the temp directory path
+ * @returns Promise that resolves when the callback and cleanup are done
+ */
+function withTempDir(fn) {
+	const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "jsdoczoom-cache-"));
+	return fn(tmpDir).finally(() => fs.rmSync(tmpDir, { recursive: true }));
+}
+describe("computeContentHash", () => {
+	it("returns consistent SHA-256 hex for same input", () => {
+		const content = "hello world";
+		const hash1 = computeContentHash(content);
+		const hash2 = computeContentHash(content);
+		expect(hash1).toBe(hash2);
+		expect(hash1).toMatch(/^[a-f0-9]{64}$/);
+	});
+	it("returns different hashes for different input", () => {
+		const hash1 = computeContentHash("content A");
+		const hash2 = computeContentHash("content B");
+		expect(hash1).not.toBe(hash2);
+	});
+});
+describe("readCacheEntry", () => {
+	it("returns null for cache miss (file not found)", async () => {
+		await withTempDir(async (dir) => {
+			const config = { enabled: true, directory: dir };
+			const result = await readCacheEntry(config, "drilldown", "nonexistent");
+			expect(result).toBeNull();
+		});
+	});
+	it("returns null for corrupted/unparseable cache file (invalid JSON)", async () => {
+		await withTempDir(async (dir) => {
+			const config = { enabled: true, directory: dir };
+			const mode = "drilldown";
+			const hash = "corrupted";
+			// Create directory and write invalid JSON
+			await ensureCacheDir(config, mode);
+			const filePath = path.join(dir, mode, `${hash}.json`);
+			fs.writeFileSync(filePath, "{ invalid json }", "utf-8");
+			const result = await readCacheEntry(config, mode, hash);
+			expect(result).toBeNull();
+		});
+	});
+});
+describe("writeCacheEntry and readCacheEntry", () => {
+	it("returns stored data after writing", async () => {
+		await withTempDir(async (dir) => {
+			const config = { enabled: true, directory: dir };
+			const mode = "lint";
+			const hash = "test-hash";
+			const data = { foo: "bar", count: 42 };
+			await ensureCacheDir(config, mode);
+			await writeCacheEntry(config, mode, hash, data);
+			const retrieved = await readCacheEntry(config, mode, hash);
+			expect(retrieved).toEqual(data);
+		});
+	});
+});
+describe("processWithCache", () => {
+	it("calls compute on cache miss", async () => {
+		await withTempDir(async (dir) => {
+			const config = { enabled: true, directory: dir };
+			const compute = vi.fn(() => ({ result: "computed" }));
+			const result = await processWithCache(
+				config,
+				"validate",
+				"file content",
+				compute,
+			);
+			expect(compute).toHaveBeenCalledTimes(1);
+			expect(result).toEqual({ result: "computed" });
+		});
+	});
+	it("returns cached data on cache hit without calling compute", async () => {
+		await withTempDir(async (dir) => {
+			const config = { enabled: true, directory: dir };
+			const content = "cached file content";
+			const expectedData = { result: "cached" };
+			// First call populates cache
+			await processWithCache(config, "drilldown", content, () => expectedData);
+			// Second call should hit cache
+			const compute = vi.fn(() => ({ result: "should not be called" }));
+			const result = await processWithCache(
+				config,
+				"drilldown",
+				content,
+				compute,
+			);
+			expect(compute).not.toHaveBeenCalled();
+			expect(result).toEqual(expectedData);
+		});
+	});
+	it("works when cache is disabled (always calls compute)", async () => {
+		await withTempDir(async (dir) => {
+			const config = { enabled: false, directory: dir };
+			const compute = vi.fn(() => ({ result: "computed" }));
+			const result1 = await processWithCache(
+				config,
+				"lint",
+				"content",
+				compute,
+			);
+			const result2 = await processWithCache(
+				config,
+				"lint",
+				"content",
+				compute,
+			);
+			expect(compute).toHaveBeenCalledTimes(2);
+			expect(result1).toEqual({ result: "computed" });
+			expect(result2).toEqual({ result: "computed" });
+		});
+	});
+	it("degrades gracefully when cache directory is unwritable (calls compute, does not throw)", async () => {
+		// Use a path that doesn't exist and can't be created
+		const config = {
+			enabled: true,
+			directory: "/nonexistent/readonly/path",
+		};
+		const compute = vi.fn(() => ({ result: "computed" }));
+		const result = await processWithCache(
+			config,
+			"drilldown",
+			"content",
+			compute,
+		);
+		expect(compute).toHaveBeenCalledTimes(1);
+		expect(result).toEqual({ result: "computed" });
+	});
+});
+describe("ensureCacheDir", () => {
+	it("creates nested directory structure", async () => {
+		await withTempDir(async (dir) => {
+			const config = { enabled: true, directory: dir };
+			const mode = "validate";
+			await ensureCacheDir(config, mode);
+			const expectedPath = path.join(dir, mode);
+			expect(fs.existsSync(expectedPath)).toBe(true);
+			expect(fs.statSync(expectedPath).isDirectory()).toBe(true);
+		});
+	});
+});
+describe("concurrent writes", () => {
+	it("concurrent writes to same key don't corrupt", async () => {
+		await withTempDir(async (dir) => {
+			const config = { enabled: true, directory: dir };
+			const mode = "drilldown";
+			const hash = "concurrent-key";
+			await ensureCacheDir(config, mode);
+			// Launch multiple concurrent writes
+			const writes = Array.from({ length: 10 }, (_, i) =>
+				writeCacheEntry(config, mode, hash, { value: i }),
+			);
+			await Promise.all(writes);
+			// Read back - should be valid JSON (one of the written values)
+			const retrieved = await readCacheEntry(config, mode, hash);
+			expect(retrieved).not.toBeNull();
+			expect(typeof retrieved?.value).toBe("number");
+			expect(retrieved?.value).toBeGreaterThanOrEqual(0);
+			expect(retrieved?.value).toBeLessThan(10);
+		});
+	});
+});
+describe("cache mode namespacing", () => {
+	it("cache entries are namespaced by mode", async () => {
+		await withTempDir(async (dir) => {
+			const config = { enabled: true, directory: dir };
+			const content = "shared content";
+			const drilldownData = { mode: "drilldown", value: 1 };
+			const validateData = { mode: "validate", value: 2 };
+			const lintData = { mode: "lint", value: 3 };
+			// Store same content in different modes
+			await processWithCache(config, "drilldown", content, () => drilldownData);
+			await processWithCache(config, "validate", content, () => validateData);
+			await processWithCache(config, "lint", content, () => lintData);
+			// Verify each mode returns its own cached data
+			const drilldownResult = await processWithCache(
+				config,
+				"drilldown",
+				content,
+				() => {
+					throw new Error("Should not compute");
+				},
+			);
+			const validateResult = await processWithCache(
+				config,
+				"validate",
+				content,
+				() => {
+					throw new Error("Should not compute");
+				},
+			);
+			const lintResult = await processWithCache(config, "lint", content, () => {
+				throw new Error("Should not compute");
+			});
+			expect(drilldownResult).toEqual(drilldownData);
+			expect(validateResult).toEqual(validateData);
+			expect(lintResult).toEqual(lintData);
+		});
+	});
+});