claudeup 6.2.0 → 6.3.0

package/src/__tests__/gitignore-detector.test.ts

@@ -1,168 +1,176 @@
-import { describe, it, expect, beforeEach, afterEach } from "bun:test";
-import { mkdtemp, rm, writeFile, mkdir } from "node:fs/promises";
+import { afterEach, beforeEach, describe, expect, it } from "bun:test";
+import { spawnSync } from "node:child_process";
+import { mkdir, mkdtemp, rm, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { spawnSync } from "node:child_process";
 import { detectViolations } from "../services/gitignore-detector";
 import type { ResolvedManifest } from "../types/gitignore";
 
 function git(cwd: string, ...args: string[]): string {
-  // core.excludesFile=/dev/null bypasses the developer's global gitignore
-  // so the test environment doesn't leak into the result.
-  //
-  // commit.gpgsign=false is the same isolation, one step further: a developer
-  // with signed commits makes every `git commit` here call their signer. With
-  // 1Password's SSH agent that means a prompt or an agent error, so these tests
-  // failed or timed out locally for reasons that have nothing to do with the
-  // code under test. CI has no signing config, so it only ever broke locally.
-  const r = spawnSync("git", [
-    "-c",
-    "core.excludesFile=/dev/null",
-    "-c",
-    "commit.gpgsign=false",
-    ...args,
-  ], {
-    cwd,
-    encoding: "utf8",
-  });
-  if (r.status !== 0) {
-    throw new Error(`git ${args.join(" ")} failed: ${r.stderr}`);
-  }
-  return r.stdout;
+	// core.excludesFile=/dev/null bypasses the developer's global gitignore
+	// so the test environment doesn't leak into the result.
+	//
+	// commit.gpgsign=false is the same isolation, one step further: a developer
+	// with signed commits makes every `git commit` here call their signer. With
+	// 1Password's SSH agent that means a prompt or an agent error, so these tests
+	// failed or timed out locally for reasons that have nothing to do with the
+	// code under test. CI has no signing config, so it only ever broke locally.
+	const r = spawnSync(
+		"git",
+		[
+			"-c",
+			"core.excludesFile=/dev/null",
+			"-c",
+			"commit.gpgsign=false",
+			...args,
+		],
+		{
+			cwd,
+			encoding: "utf8",
+		},
+	);
+	if (r.status !== 0) {
+		throw new Error(`git ${args.join(" ")} failed: ${r.stderr}`);
+	}
+	return r.stdout;
 }
 
 async function makeRepo(): Promise<string> {
-  const dir = await mkdtemp(join(tmpdir(), "gitig-det-"));
-  git(dir, "init", "-q");
-  git(dir, "config", "user.email", "test@test");
-  git(dir, "config", "user.name", "test");
-  return dir;
+	const dir = await mkdtemp(join(tmpdir(), "gitig-det-"));
+	git(dir, "init", "-q");
+	git(dir, "config", "user.email", "test@test");
+	git(dir, "config", "user.name", "test");
+	return dir;
 }
 
 function manifest(rules: ResolvedManifest["rules"]): ResolvedManifest {
-  return { rules, conflicts: [] };
+	return { rules, conflicts: [] };
 }
 
 describe("detectViolations", () => {
-  let repo: string;
-
-  beforeEach(async () => {
-    repo = await makeRepo();
-  });
-
-  afterEach(async () => {
-    await rm(repo, { recursive: true, force: true });
-  });
-
-  it("returns empty for non-git directory", async () => {
-    const tmp = await mkdtemp(join(tmpdir(), "gitig-nogit-"));
-    try {
-      const r = await detectViolations(
-        tmp,
-        manifest([{ pattern: ".env", action: "ignore", source: "builtin" }]),
-      );
-      expect(r).toEqual([]);
-    } finally {
-      await rm(tmp, { recursive: true, force: true });
-    }
-  });
-
-  it("flags tracked-but-should-ignore for a tracked file", async () => {
-    await writeFile(join(repo, "secret.txt"), "x");
-    git(repo, "add", "secret.txt");
-    git(repo, "commit", "-q", "-m", "add secret");
-
-    const r = await detectViolations(
-      repo,
-      manifest([{ pattern: "secret.txt", action: "ignore", source: "project" }]),
-    );
-    expect(r.length).toBe(1);
-    expect(r[0].kind).toBe("tracked-but-should-ignore");
-    expect(r[0].severity).toBe("destructive");
-    expect(r[0].path).toBe("secret.txt");
-  });
-
-  it("flags missing-from-gitignore when path neither tracked nor in .gitignore", async () => {
-    const r = await detectViolations(
-      repo,
-      manifest([{ pattern: ".env", action: "ignore", source: "builtin" }]),
-    );
-    expect(r.length).toBe(1);
-    expect(r[0].kind).toBe("missing-from-gitignore");
-    expect(r[0].severity).toBe("safe");
-  });
-
-  it("does NOT flag missing-from-gitignore when .gitignore already covers the path", async () => {
-    await writeFile(join(repo, ".gitignore"), ".env\n");
-    const r = await detectViolations(
-      repo,
-      manifest([{ pattern: ".env", action: "ignore", source: "builtin" }]),
-    );
-    expect(r).toEqual([]);
-  });
-
-  it("flags ignored-but-should-track when track rule is excluded by .gitignore", async () => {
-    await writeFile(join(repo, ".gitignore"), ".mcp.json\n");
-    await writeFile(join(repo, ".mcp.json"), "{}");
-    const r = await detectViolations(
-      repo,
-      manifest([{ pattern: ".mcp.json", action: "track", source: "builtin" }]),
-    );
-    expect(r.length).toBe(1);
-    expect(r[0].kind).toBe("ignored-but-should-track");
-    expect(r[0].severity).toBe("destructive");
-  });
-
-  it("flags untracked-and-should-track when path exists but isn't tracked", async () => {
-    await writeFile(join(repo, ".mcp.json"), "{}");
-    const r = await detectViolations(
-      repo,
-      manifest([{ pattern: ".mcp.json", action: "track", source: "builtin" }]),
-    );
-    expect(r.length).toBe(1);
-    expect(r[0].kind).toBe("untracked-and-should-track");
-    expect(r[0].severity).toBe("destructive");
-  });
-
-  it("does NOT flag track rule when path is already tracked", async () => {
-    await writeFile(join(repo, ".mcp.json"), "{}");
-    git(repo, "add", ".mcp.json");
-    git(repo, "commit", "-q", "-m", "add mcp");
-    const r = await detectViolations(
-      repo,
-      manifest([{ pattern: ".mcp.json", action: "track", source: "builtin" }]),
-    );
-    expect(r).toEqual([]);
-  });
-
-  it("matches directory patterns against tracked subpaths", async () => {
-    await mkdir(join(repo, "ai-docs", "sessions"), { recursive: true });
-    await writeFile(join(repo, "ai-docs", "sessions", "leak.md"), "x");
-    git(repo, "add", "ai-docs/sessions/leak.md");
-    git(repo, "commit", "-q", "-m", "leak");
-
-    const r = await detectViolations(
-      repo,
-      manifest([{ pattern: "ai-docs/sessions/", action: "ignore", source: "builtin" }]),
-    );
-    expect(r.length).toBeGreaterThan(0);
-    expect(r[0].kind).toBe("tracked-but-should-ignore");
-    expect(r[0].path).toBe("ai-docs/sessions/leak.md");
-  });
-
-  it("returns no violations when manifest is satisfied", async () => {
-    await writeFile(join(repo, ".gitignore"), ".env\n");
-    await writeFile(join(repo, ".mcp.json"), "{}");
-    git(repo, "add", ".gitignore", ".mcp.json");
-    git(repo, "commit", "-q", "-m", "init");
-
-    const r = await detectViolations(
-      repo,
-      manifest([
-        { pattern: ".env", action: "ignore", source: "builtin" },
-        { pattern: ".mcp.json", action: "track", source: "builtin" },
-      ]),
-    );
-    expect(r).toEqual([]);
-  });
+	let repo: string;
+
+	beforeEach(async () => {
+		repo = await makeRepo();
+	});
+
+	afterEach(async () => {
+		await rm(repo, { recursive: true, force: true });
+	});
+
+	it("returns empty for non-git directory", async () => {
+		const tmp = await mkdtemp(join(tmpdir(), "gitig-nogit-"));
+		try {
+			const r = await detectViolations(
+				tmp,
+				manifest([{ pattern: ".env", action: "ignore", source: "builtin" }]),
+			);
+			expect(r).toEqual([]);
+		} finally {
+			await rm(tmp, { recursive: true, force: true });
+		}
+	});
+
+	it("flags tracked-but-should-ignore for a tracked file", async () => {
+		await writeFile(join(repo, "secret.txt"), "x");
+		git(repo, "add", "secret.txt");
+		git(repo, "commit", "-q", "-m", "add secret");
+
+		const r = await detectViolations(
+			repo,
+			manifest([
+				{ pattern: "secret.txt", action: "ignore", source: "project" },
+			]),
+		);
+		expect(r.length).toBe(1);
+		expect(r[0].kind).toBe("tracked-but-should-ignore");
+		expect(r[0].severity).toBe("destructive");
+		expect(r[0].path).toBe("secret.txt");
+	});
+
+	it("flags missing-from-gitignore when path neither tracked nor in .gitignore", async () => {
+		const r = await detectViolations(
+			repo,
+			manifest([{ pattern: ".env", action: "ignore", source: "builtin" }]),
+		);
+		expect(r.length).toBe(1);
+		expect(r[0].kind).toBe("missing-from-gitignore");
+		expect(r[0].severity).toBe("safe");
+	});
+
+	it("does NOT flag missing-from-gitignore when .gitignore already covers the path", async () => {
+		await writeFile(join(repo, ".gitignore"), ".env\n");
+		const r = await detectViolations(
+			repo,
+			manifest([{ pattern: ".env", action: "ignore", source: "builtin" }]),
+		);
+		expect(r).toEqual([]);
+	});
+
+	it("flags ignored-but-should-track when track rule is excluded by .gitignore", async () => {
+		await writeFile(join(repo, ".gitignore"), ".mcp.json\n");
+		await writeFile(join(repo, ".mcp.json"), "{}");
+		const r = await detectViolations(
+			repo,
+			manifest([{ pattern: ".mcp.json", action: "track", source: "builtin" }]),
+		);
+		expect(r.length).toBe(1);
+		expect(r[0].kind).toBe("ignored-but-should-track");
+		expect(r[0].severity).toBe("destructive");
+	});
+
+	it("flags untracked-and-should-track when path exists but isn't tracked", async () => {
+		await writeFile(join(repo, ".mcp.json"), "{}");
+		const r = await detectViolations(
+			repo,
+			manifest([{ pattern: ".mcp.json", action: "track", source: "builtin" }]),
+		);
+		expect(r.length).toBe(1);
+		expect(r[0].kind).toBe("untracked-and-should-track");
+		expect(r[0].severity).toBe("destructive");
+	});
+
+	it("does NOT flag track rule when path is already tracked", async () => {
+		await writeFile(join(repo, ".mcp.json"), "{}");
+		git(repo, "add", ".mcp.json");
+		git(repo, "commit", "-q", "-m", "add mcp");
+		const r = await detectViolations(
+			repo,
+			manifest([{ pattern: ".mcp.json", action: "track", source: "builtin" }]),
+		);
+		expect(r).toEqual([]);
+	});
+
+	it("matches directory patterns against tracked subpaths", async () => {
+		await mkdir(join(repo, "ai-docs", "sessions"), { recursive: true });
+		await writeFile(join(repo, "ai-docs", "sessions", "leak.md"), "x");
+		git(repo, "add", "ai-docs/sessions/leak.md");
+		git(repo, "commit", "-q", "-m", "leak");
+
+		const r = await detectViolations(
+			repo,
+			manifest([
+				{ pattern: "ai-docs/sessions/", action: "ignore", source: "builtin" },
+			]),
+		);
+		expect(r.length).toBeGreaterThan(0);
+		expect(r[0].kind).toBe("tracked-but-should-ignore");
+		expect(r[0].path).toBe("ai-docs/sessions/leak.md");
+	});
+
+	it("returns no violations when manifest is satisfied", async () => {
+		await writeFile(join(repo, ".gitignore"), ".env\n");
+		await writeFile(join(repo, ".mcp.json"), "{}");
+		git(repo, "add", ".gitignore", ".mcp.json");
+		git(repo, "commit", "-q", "-m", "init");
+
+		const r = await detectViolations(
+			repo,
+			manifest([
+				{ pattern: ".env", action: "ignore", source: "builtin" },
+				{ pattern: ".mcp.json", action: "track", source: "builtin" },
+			]),
+		);
+		expect(r).toEqual([]);
+	});
 });