claude-crap 0.3.6 → 0.3.8

package/src/tests/file-detail-api.test.ts

@@ -0,0 +1,258 @@
+/**
+ * Unit tests for the /api/file-detail endpoint logic.
+ *
+ * These tests exercise the file detail builder function directly,
+ * without spawning the full MCP server. They verify that source lines,
+ * function metrics, and filtered findings are returned correctly.
+ *
+ * @module tests/file-detail-api.test
+ */
+
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { buildFileDetail } from "../dashboard/file-detail.js";
+import { TreeSitterEngine } from "../ast/tree-sitter-engine.js";
+import { SarifStore } from "../sarif/sarif-store.js";
+import { wrapResultsInSarif } from "../adapters/common.js";
+
+function makeTmpDir(): string {
+  return mkdtempSync(join(tmpdir(), "crap-file-detail-"));
+}
+
+const SAMPLE_TS = `export function greet(name: string): string {
+  return "hello " + name;
+}
+
+export function classify(x: number): string {
+  if (x < 0) return "negative";
+  if (x === 0) return "zero";
+  if (x < 10) return "small";
+  if (x < 100) return "medium";
+  return "large";
+}
+`;
+
+describe("buildFileDetail", () => {
+  const engine = new TreeSitterEngine();
+
+  it("returns source lines for a valid file", async () => {
+    const dir = makeTmpDir();
+    try {
+      writeFileSync(join(dir, "hello.ts"), SAMPLE_TS);
+      const store = new SarifStore({
+        workspaceRoot: dir,
+        outputDir: join(dir, ".claude-crap/reports"),
+      });
+      const result = await buildFileDetail({
+        relativePath: "hello.ts",
+        workspaceRoot: dir,
+        astEngine: engine,
+        sarifStore: store,
+        cyclomaticMax: 15,
+      });
+      assert.equal(result.filePath, "hello.ts");
+      assert.ok(result.sourceLines.length > 0);
+      assert.ok(result.sourceLines[0]!.includes("export function greet"));
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("returns function metrics for supported languages", async () => {
+    const dir = makeTmpDir();
+    try {
+      writeFileSync(join(dir, "hello.ts"), SAMPLE_TS);
+      const store = new SarifStore({
+        workspaceRoot: dir,
+        outputDir: join(dir, ".claude-crap/reports"),
+      });
+      const result = await buildFileDetail({
+        relativePath: "hello.ts",
+        workspaceRoot: dir,
+        astEngine: engine,
+        sarifStore: store,
+        cyclomaticMax: 15,
+      });
+      assert.equal(result.language, "typescript");
+      assert.ok(result.functions.length >= 2);
+      const greet = result.functions.find((f) => f.name === "greet");
+      assert.ok(greet);
+      assert.equal(greet.cyclomaticComplexity, 1);
+      const classify = result.functions.find((f) => f.name === "classify");
+      assert.ok(classify);
+      assert.ok(classify.cyclomaticComplexity >= 4);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("filters findings to the requested file only", async () => {
+    const dir = makeTmpDir();
+    try {
+      writeFileSync(join(dir, "a.ts"), 'export const a = 1;\n');
+      writeFileSync(join(dir, "b.ts"), 'export const b = 2;\n');
+
+      const store = new SarifStore({
+        workspaceRoot: dir,
+        outputDir: join(dir, ".claude-crap/reports"),
+      });
+
+      // Ingest findings for both files
+      const doc = wrapResultsInSarif("eslint" as never, "0.1.0", [
+        {
+          ruleId: "no-unused-vars",
+          level: "warning",
+          message: { text: "unused in a" },
+          locations: [{
+            physicalLocation: {
+              artifactLocation: { uri: "a.ts" },
+              region: { startLine: 1, startColumn: 1 },
+            },
+          }],
+          properties: { sourceTool: "eslint", effortMinutes: 30 },
+        },
+        {
+          ruleId: "no-unused-vars",
+          level: "warning",
+          message: { text: "unused in b" },
+          locations: [{
+            physicalLocation: {
+              artifactLocation: { uri: "b.ts" },
+              region: { startLine: 1, startColumn: 1 },
+            },
+          }],
+          properties: { sourceTool: "eslint", effortMinutes: 30 },
+        },
+      ]);
+      store.ingestRun(doc, "eslint");
+
+      const result = await buildFileDetail({
+        relativePath: "a.ts",
+        workspaceRoot: dir,
+        astEngine: engine,
+        sarifStore: store,
+        cyclomaticMax: 15,
+      });
+
+      assert.equal(result.findings.length, 1);
+      assert.ok(result.findings[0]!.message.includes("unused in a"));
+      assert.equal(result.summary.totalFindings, 1);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("throws for non-existent file", async () => {
+    const dir = makeTmpDir();
+    try {
+      const store = new SarifStore({
+        workspaceRoot: dir,
+        outputDir: join(dir, ".claude-crap/reports"),
+      });
+      await assert.rejects(
+        buildFileDetail({
+          relativePath: "nonexistent.ts",
+          workspaceRoot: dir,
+          astEngine: engine,
+          sarifStore: store,
+          cyclomaticMax: 15,
+        }),
+        /not found|ENOENT/i,
+      );
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("rejects path traversal attempts", async () => {
+    const dir = makeTmpDir();
+    try {
+      const store = new SarifStore({
+        workspaceRoot: dir,
+        outputDir: join(dir, ".claude-crap/reports"),
+      });
+      await assert.rejects(
+        buildFileDetail({
+          relativePath: "../../etc/passwd",
+          workspaceRoot: dir,
+          astEngine: engine,
+          sarifStore: store,
+          cyclomaticMax: 15,
+        }),
+        /escapes the workspace/i,
+      );
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("returns empty functions for unsupported languages", async () => {
+    const dir = makeTmpDir();
+    try {
+      writeFileSync(join(dir, "data.json"), '{"key": "value"}\n');
+      const store = new SarifStore({
+        workspaceRoot: dir,
+        outputDir: join(dir, ".claude-crap/reports"),
+      });
+      const result = await buildFileDetail({
+        relativePath: "data.json",
+        workspaceRoot: dir,
+        astEngine: engine,
+        sarifStore: store,
+        cyclomaticMax: 15,
+      });
+      assert.equal(result.language, null);
+      assert.equal(result.functions.length, 0);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+
+  it("computes summary with correct effort and complexity stats", async () => {
+    const dir = makeTmpDir();
+    try {
+      writeFileSync(join(dir, "hello.ts"), SAMPLE_TS);
+      const store = new SarifStore({
+        workspaceRoot: dir,
+        outputDir: join(dir, ".claude-crap/reports"),
+      });
+
+      const doc = wrapResultsInSarif("eslint" as never, "0.1.0", [
+        {
+          ruleId: "no-magic-numbers",
+          level: "warning",
+          message: { text: "magic number" },
+          locations: [{
+            physicalLocation: {
+              artifactLocation: { uri: "hello.ts" },
+              region: { startLine: 6, startColumn: 7 },
+            },
+          }],
+          properties: { sourceTool: "eslint", effortMinutes: 30 },
+        },
+      ]);
+      store.ingestRun(doc, "eslint");
+
+      const result = await buildFileDetail({
+        relativePath: "hello.ts",
+        workspaceRoot: dir,
+        astEngine: engine,
+        sarifStore: store,
+        cyclomaticMax: 15,
+      });
+
+      assert.equal(result.summary.totalFindings, 1);
+      assert.equal(result.summary.warningCount, 1);
+      assert.equal(result.summary.errorCount, 0);
+      assert.ok(result.summary.totalEffortMinutes >= 30);
+      assert.ok(result.summary.maxComplexity >= 4); // classify has CC>=4
+      assert.ok(result.summary.avgComplexity > 0);
+    } finally {
+      rmSync(dir, { recursive: true, force: true });
+    }
+  });
+});

package/src/tests/scanner-detector.test.ts

@@ -90,24 +90,34 @@ describe("detectScanners", () => {
     }
   });
 
-  it("detects eslint from package.json devDependencies", async () => {
+  it("detects eslint from package.json — not installed vs installed", async () => {
     const dir = makeTmpDir();
     try {
       writeFileSync(
         join(dir, "package.json"),
         JSON.stringify({ devDependencies: { eslint: "^9.0.0" } }),
       );
+      // Without node_modules/.bin/eslint — declared but not installed
       const results = await detectScanners(dir);
       const eslint = results.find((r) => r.scanner === "eslint");
       assert.ok(eslint);
-      assert.equal(eslint.available, true);
-      assert.ok(eslint.reason.includes("package.json"));
+      assert.equal(eslint.available, false);
+      assert.ok(eslint.reason.includes("not installed"));
+
+      // With binary present — installed
+      mkdirSync(join(dir, "node_modules", ".bin"), { recursive: true });
+      writeFileSync(join(dir, "node_modules", ".bin", "eslint"), "");
+      const results2 = await detectScanners(dir);
+      const eslint2 = results2.find((r) => r.scanner === "eslint");
+      assert.ok(eslint2);
+      assert.equal(eslint2.available, true);
+      assert.ok(eslint2.reason.includes("installed"));
     } finally {
       rmSync(dir, { recursive: true, force: true });
     }
   });
 
-  it("detects stryker from package.json @stryker-mutator/core", async () => {
+  it("detects stryker from package.json — not installed vs installed", async () => {
     const dir = makeTmpDir();
     try {
       writeFileSync(
@@ -116,11 +126,21 @@ describe("detectScanners", () => {
           devDependencies: { "@stryker-mutator/core": "^7.0.0" },
         }),
       );
+      // Without binary — declared but not installed
       const results = await detectScanners(dir);
       const stryker = results.find((r) => r.scanner === "stryker");
       assert.ok(stryker);
-      assert.equal(stryker.available, true);
-      assert.ok(stryker.reason.includes("package.json"));
+      assert.equal(stryker.available, false);
+      assert.ok(stryker.reason.includes("not installed"));
+
+      // With binary present — installed
+      mkdirSync(join(dir, "node_modules", ".bin"), { recursive: true });
+      writeFileSync(join(dir, "node_modules", ".bin", "stryker"), "");
+      const results2 = await detectScanners(dir);
+      const stryker2 = results2.find((r) => r.scanner === "stryker");
+      assert.ok(stryker2);
+      assert.equal(stryker2.available, true);
+      assert.ok(stryker2.reason.includes("installed"));
     } finally {
       rmSync(dir, { recursive: true, force: true });
     }
@@ -133,9 +153,9 @@ describe("detectScanners", () => {
       // Config and package.json probes will all fail.
       // Binary probe results depend on the host — don't assert on those,
       // but do assert the structure is correct.
-      assert.equal(results.length, 4);
+      assert.equal(results.length, 5);
       for (const r of results) {
-        assert.ok(["eslint", "semgrep", "bandit", "stryker"].includes(r.scanner));
+        assert.ok(["eslint", "semgrep", "bandit", "stryker", "dart_analyze"].includes(r.scanner));
         assert.equal(typeof r.available, "boolean");
         assert.equal(typeof r.reason, "string");
       }
@@ -150,7 +170,7 @@ describe("detectScanners", () => {
       writeFileSync(join(dir, "package.json"), "not json at all");
       // Should not throw — just skip the package.json probe
       const results = await detectScanners(dir);
-      assert.equal(results.length, 4);
+      assert.equal(results.length, 5);
     } finally {
       rmSync(dir, { recursive: true, force: true });
     }
@@ -172,10 +192,10 @@ describe("detectScanners", () => {
     }
   });
 
-  it("SCANNER_SIGNALS covers all four scanners", () => {
+  it("SCANNER_SIGNALS covers all supported scanners", () => {
     assert.deepEqual(
       Object.keys(SCANNER_SIGNALS).sort(),
-      ["bandit", "eslint", "semgrep", "stryker"],
+      ["bandit", "dart_analyze", "eslint", "semgrep", "stryker"],
     );
   });
 });