gsd-pi 2.44.0-dev.848dd4c → 2.44.0

package/src/resources/extensions/gsd/tests/detection.test.ts

@@ -38,315 +38,361 @@ function cleanup(dir: string): void {
 
 // ─── detectProjectState ─────────────────────────────────────────────────────────
 
-test("detectProjectState: empty directory returns state=none", (t) => {
+test("detectProjectState: empty directory returns state=none", () => {
   const dir = makeTempDir("empty");
-  t.after(() => cleanup(dir));
-
-  const result = detectProjectState(dir);
-  assert.equal(result.state, "none");
-  assert.equal(result.v1, undefined);
-  assert.equal(result.v2, undefined);
+  try {
+    const result = detectProjectState(dir);
+    assert.equal(result.state, "none");
+    assert.equal(result.v1, undefined);
+    assert.equal(result.v2, undefined);
+  } finally {
+    cleanup(dir);
+  }
 });
 
-test("detectProjectState: directory with .gsd/milestones/M001 returns v2-gsd", (t) => {
+test("detectProjectState: directory with .gsd/milestones/M001 returns v2-gsd", () => {
   const dir = makeTempDir("v2-gsd");
-  t.after(() => cleanup(dir));
-
-  mkdirSync(join(dir, ".gsd", "milestones", "M001"), { recursive: true });
-  const result = detectProjectState(dir);
-  assert.equal(result.state, "v2-gsd");
-  assert.ok(result.v2);
-  assert.equal(result.v2!.milestoneCount, 1);
+  try {
+    mkdirSync(join(dir, ".gsd", "milestones", "M001"), { recursive: true });
+    const result = detectProjectState(dir);
+    assert.equal(result.state, "v2-gsd");
+    assert.ok(result.v2);
+    assert.equal(result.v2!.milestoneCount, 1);
+  } finally {
+    cleanup(dir);
+  }
 });
 
-test("detectProjectState: directory with empty .gsd/milestones returns v2-gsd-empty", (t) => {
+test("detectProjectState: directory with empty .gsd/milestones returns v2-gsd-empty", () => {
   const dir = makeTempDir("v2-empty");
-  t.after(() => cleanup(dir));
-
-  mkdirSync(join(dir, ".gsd", "milestones"), { recursive: true });
-  const result = detectProjectState(dir);
-  assert.equal(result.state, "v2-gsd-empty");
-  assert.ok(result.v2);
-  assert.equal(result.v2!.milestoneCount, 0);
+  try {
+    mkdirSync(join(dir, ".gsd", "milestones"), { recursive: true });
+    const result = detectProjectState(dir);
+    assert.equal(result.state, "v2-gsd-empty");
+    assert.ok(result.v2);
+    assert.equal(result.v2!.milestoneCount, 0);
+  } finally {
+    cleanup(dir);
+  }
 });
 
-test("detectProjectState: directory with .planning/ returns v1-planning", (t) => {
+test("detectProjectState: directory with .planning/ returns v1-planning", () => {
   const dir = makeTempDir("v1-planning");
-  t.after(() => cleanup(dir));
-
-  mkdirSync(join(dir, ".planning", "phases", "01-setup"), { recursive: true });
-  writeFileSync(join(dir, ".planning", "ROADMAP.md"), "# Roadmap\n", "utf-8");
-  const result = detectProjectState(dir);
-  assert.equal(result.state, "v1-planning");
-  assert.ok(result.v1);
-  assert.equal(result.v1!.hasRoadmap, true);
-  assert.equal(result.v1!.hasPhasesDir, true);
-  assert.equal(result.v1!.phaseCount, 1);
+  try {
+    mkdirSync(join(dir, ".planning", "phases", "01-setup"), { recursive: true });
+    writeFileSync(join(dir, ".planning", "ROADMAP.md"), "# Roadmap\n", "utf-8");
+    const result = detectProjectState(dir);
+    assert.equal(result.state, "v1-planning");
+    assert.ok(result.v1);
+    assert.equal(result.v1!.hasRoadmap, true);
+    assert.equal(result.v1!.hasPhasesDir, true);
+    assert.equal(result.v1!.phaseCount, 1);
+  } finally {
+    cleanup(dir);
+  }
 });
 
-test("detectProjectState: v2 takes priority over v1 when both exist", (t) => {
+test("detectProjectState: v2 takes priority over v1 when both exist", () => {
   const dir = makeTempDir("both");
-  t.after(() => cleanup(dir));
-
-  mkdirSync(join(dir, ".gsd", "milestones", "M001"), { recursive: true });
-  mkdirSync(join(dir, ".planning"), { recursive: true });
-  const result = detectProjectState(dir);
-  assert.equal(result.state, "v2-gsd");
+  try {
+    mkdirSync(join(dir, ".gsd", "milestones", "M001"), { recursive: true });
+    mkdirSync(join(dir, ".planning"), { recursive: true });
+    const result = detectProjectState(dir);
+    assert.equal(result.state, "v2-gsd");
+  } finally {
+    cleanup(dir);
+  }
 });
 
-test("detectProjectState: detects preferences in .gsd/", (t) => {
+test("detectProjectState: detects preferences in .gsd/", () => {
   const dir = makeTempDir("prefs");
-  t.after(() => cleanup(dir));
-
-  mkdirSync(join(dir, ".gsd", "milestones"), { recursive: true });
-  writeFileSync(join(dir, ".gsd", "preferences.md"), "---\nversion: 1\n---\n", "utf-8");
-  const result = detectProjectState(dir);
-  assert.ok(result.v2);
-  assert.equal(result.v2!.hasPreferences, true);
+  try {
+    mkdirSync(join(dir, ".gsd", "milestones"), { recursive: true });
+    writeFileSync(join(dir, ".gsd", "preferences.md"), "---\nversion: 1\n---\n", "utf-8");
+    const result = detectProjectState(dir);
+    assert.ok(result.v2);
+    assert.equal(result.v2!.hasPreferences, true);
+  } finally {
+    cleanup(dir);
+  }
 });
 
 // ─── detectV1Planning ───────────────────────────────────────────────────────────
 
-test("detectV1Planning: returns null for missing .planning/", (t) => {
+test("detectV1Planning: returns null for missing .planning/", () => {
   const dir = makeTempDir("no-v1");
-  t.after(() => cleanup(dir));
-
-  assert.equal(detectV1Planning(dir), null);
+  try {
+    assert.equal(detectV1Planning(dir), null);
+  } finally {
+    cleanup(dir);
+  }
 });
 
-test("detectV1Planning: returns null when .planning is a file", (t) => {
+test("detectV1Planning: returns null when .planning is a file", () => {
   const dir = makeTempDir("v1-file");
-  t.after(() => cleanup(dir));
-
-  writeFileSync(join(dir, ".planning"), "not a directory", "utf-8");
-  assert.equal(detectV1Planning(dir), null);
+  try {
+    writeFileSync(join(dir, ".planning"), "not a directory", "utf-8");
+    assert.equal(detectV1Planning(dir), null);
+  } finally {
+    cleanup(dir);
+  }
 });
 
-test("detectV1Planning: detects phases directory with multiple phases", (t) => {
+test("detectV1Planning: detects phases directory with multiple phases", () => {
   const dir = makeTempDir("v1-phases");
-  t.after(() => cleanup(dir));
-
-  mkdirSync(join(dir, ".planning", "phases", "01-setup"), { recursive: true });
-  mkdirSync(join(dir, ".planning", "phases", "02-core"), { recursive: true });
-  mkdirSync(join(dir, ".planning", "phases", "03-deploy"), { recursive: true });
-  const result = detectV1Planning(dir);
-  assert.ok(result);
-  assert.equal(result!.phaseCount, 3);
-  assert.equal(result!.hasPhasesDir, true);
+  try {
+    mkdirSync(join(dir, ".planning", "phases", "01-setup"), { recursive: true });
+    mkdirSync(join(dir, ".planning", "phases", "02-core"), { recursive: true });
+    mkdirSync(join(dir, ".planning", "phases", "03-deploy"), { recursive: true });
+    const result = detectV1Planning(dir);
+    assert.ok(result);
+    assert.equal(result!.phaseCount, 3);
+    assert.equal(result!.hasPhasesDir, true);
+  } finally {
+    cleanup(dir);
+  }
 });
 
-test("detectV1Planning: detects ROADMAP.md", (t) => {
+test("detectV1Planning: detects ROADMAP.md", () => {
   const dir = makeTempDir("v1-roadmap");
-  t.after(() => cleanup(dir));
-
-  mkdirSync(join(dir, ".planning"), { recursive: true });
-  writeFileSync(join(dir, ".planning", "ROADMAP.md"), "# Roadmap", "utf-8");
-  const result = detectV1Planning(dir);
-  assert.ok(result);
-  assert.equal(result!.hasRoadmap, true);
-  assert.equal(result!.hasPhasesDir, false);
-  assert.equal(result!.phaseCount, 0);
+  try {
+    mkdirSync(join(dir, ".planning"), { recursive: true });
+    writeFileSync(join(dir, ".planning", "ROADMAP.md"), "# Roadmap", "utf-8");
+    const result = detectV1Planning(dir);
+    assert.ok(result);
+    assert.equal(result!.hasRoadmap, true);
+    assert.equal(result!.hasPhasesDir, false);
+    assert.equal(result!.phaseCount, 0);
+  } finally {
+    cleanup(dir);
+  }
 });
 
 // ─── detectProjectSignals ───────────────────────────────────────────────────────
 
-test("detectProjectSignals: empty directory", (t) => {
+test("detectProjectSignals: empty directory", () => {
   const dir = makeTempDir("signals-empty");
-  t.after(() => cleanup(dir));
-
-  const signals = detectProjectSignals(dir);
-  assert.deepEqual(signals.detectedFiles, []);
-  assert.equal(signals.isGitRepo, false);
-  assert.equal(signals.isMonorepo, false);
-  assert.equal(signals.primaryLanguage, undefined);
-  assert.equal(signals.hasCI, false);
-  assert.equal(signals.hasTests, false);
-  assert.deepEqual(signals.verificationCommands, []);
+  try {
+    const signals = detectProjectSignals(dir);
+    assert.deepEqual(signals.detectedFiles, []);
+    assert.equal(signals.isGitRepo, false);
+    assert.equal(signals.isMonorepo, false);
+    assert.equal(signals.primaryLanguage, undefined);
+    assert.equal(signals.hasCI, false);
+    assert.equal(signals.hasTests, false);
+    assert.deepEqual(signals.verificationCommands, []);
+  } finally {
+    cleanup(dir);
+  }
 });
 
-test("detectProjectSignals: Node.js project", (t) => {
+test("detectProjectSignals: Node.js project", () => {
   const dir = makeTempDir("signals-node");
-  t.after(() => cleanup(dir));
-
-  writeFileSync(
-    join(dir, "package.json"),
-    JSON.stringify({
-      name: "test-project",
-      scripts: {
-        test: "jest",
-        build: "tsc",
-        lint: "eslint .",
-      },
-    }),
-    "utf-8",
-  );
-  writeFileSync(join(dir, "package-lock.json"), "{}", "utf-8");
-  mkdirSync(join(dir, ".git"), { recursive: true });
-
-  const signals = detectProjectSignals(dir);
-  assert.ok(signals.detectedFiles.includes("package.json"));
-  assert.equal(signals.primaryLanguage, "javascript/typescript");
-  assert.equal(signals.isGitRepo, true);
-  assert.equal(signals.packageManager, "npm");
-  assert.ok(signals.verificationCommands.includes("npm test"));
-  assert.ok(signals.verificationCommands.some(c => c.includes("build")));
-  assert.ok(signals.verificationCommands.some(c => c.includes("lint")));
+  try {
+    writeFileSync(
+      join(dir, "package.json"),
+      JSON.stringify({
+        name: "test-project",
+        scripts: {
+          test: "jest",
+          build: "tsc",
+          lint: "eslint .",
+        },
+      }),
+      "utf-8",
+    );
+    writeFileSync(join(dir, "package-lock.json"), "{}", "utf-8");
+    mkdirSync(join(dir, ".git"), { recursive: true });
+
+    const signals = detectProjectSignals(dir);
+    assert.ok(signals.detectedFiles.includes("package.json"));
+    assert.equal(signals.primaryLanguage, "javascript/typescript");
+    assert.equal(signals.isGitRepo, true);
+    assert.equal(signals.packageManager, "npm");
+    assert.ok(signals.verificationCommands.includes("npm test"));
+    assert.ok(signals.verificationCommands.some(c => c.includes("build")));
+    assert.ok(signals.verificationCommands.some(c => c.includes("lint")));
+  } finally {
+    cleanup(dir);
+  }
 });
 
-test("detectProjectSignals: Rust project", (t) => {
+test("detectProjectSignals: Rust project", () => {
   const dir = makeTempDir("signals-rust");
-  t.after(() => cleanup(dir));
-
-  writeFileSync(join(dir, "Cargo.toml"), '[package]\nname = "test"\n', "utf-8");
-  const signals = detectProjectSignals(dir);
-  assert.ok(signals.detectedFiles.includes("Cargo.toml"));
-  assert.equal(signals.primaryLanguage, "rust");
-  assert.ok(signals.verificationCommands.includes("cargo test"));
-  assert.ok(signals.verificationCommands.includes("cargo clippy"));
+  try {
+    writeFileSync(join(dir, "Cargo.toml"), '[package]\nname = "test"\n', "utf-8");
+    const signals = detectProjectSignals(dir);
+    assert.ok(signals.detectedFiles.includes("Cargo.toml"));
+    assert.equal(signals.primaryLanguage, "rust");
+    assert.ok(signals.verificationCommands.includes("cargo test"));
+    assert.ok(signals.verificationCommands.includes("cargo clippy"));
+  } finally {
+    cleanup(dir);
+  }
 });
 
-test("detectProjectSignals: Go project", (t) => {
+test("detectProjectSignals: Go project", () => {
   const dir = makeTempDir("signals-go");
-  t.after(() => cleanup(dir));
-
-  writeFileSync(join(dir, "go.mod"), "module example.com/test\n", "utf-8");
-  const signals = detectProjectSignals(dir);
-  assert.ok(signals.detectedFiles.includes("go.mod"));
-  assert.equal(signals.primaryLanguage, "go");
-  assert.ok(signals.verificationCommands.includes("go test ./..."));
+  try {
+    writeFileSync(join(dir, "go.mod"), "module example.com/test\n", "utf-8");
+    const signals = detectProjectSignals(dir);
+    assert.ok(signals.detectedFiles.includes("go.mod"));
+    assert.equal(signals.primaryLanguage, "go");
+    assert.ok(signals.verificationCommands.includes("go test ./..."));
+  } finally {
+    cleanup(dir);
+  }
 });
 
-test("detectProjectSignals: Python project", (t) => {
+test("detectProjectSignals: Python project", () => {
   const dir = makeTempDir("signals-python");
-  t.after(() => cleanup(dir));
-
-  writeFileSync(join(dir, "pyproject.toml"), "[tool.poetry]\n", "utf-8");
-  const signals = detectProjectSignals(dir);
-  assert.ok(signals.detectedFiles.includes("pyproject.toml"));
-  assert.equal(signals.primaryLanguage, "python");
-  assert.ok(signals.verificationCommands.includes("pytest"));
+  try {
+    writeFileSync(join(dir, "pyproject.toml"), "[tool.poetry]\n", "utf-8");
+    const signals = detectProjectSignals(dir);
+    assert.ok(signals.detectedFiles.includes("pyproject.toml"));
+    assert.equal(signals.primaryLanguage, "python");
+    assert.ok(signals.verificationCommands.includes("pytest"));
+  } finally {
+    cleanup(dir);
+  }
 });
 
-test("detectProjectSignals: monorepo detection via workspaces", (t) => {
+test("detectProjectSignals: monorepo detection via workspaces", () => {
   const dir = makeTempDir("signals-monorepo");
-  t.after(() => cleanup(dir));
-
-  writeFileSync(
-    join(dir, "package.json"),
-    JSON.stringify({ name: "mono", workspaces: ["packages/*"] }),
-    "utf-8",
-  );
-  const signals = detectProjectSignals(dir);
-  assert.equal(signals.isMonorepo, true);
+  try {
+    writeFileSync(
+      join(dir, "package.json"),
+      JSON.stringify({ name: "mono", workspaces: ["packages/*"] }),
+      "utf-8",
+    );
+    const signals = detectProjectSignals(dir);
+    assert.equal(signals.isMonorepo, true);
+  } finally {
+    cleanup(dir);
+  }
 });
 
-test("detectProjectSignals: monorepo detection via turbo.json", (t) => {
+test("detectProjectSignals: monorepo detection via turbo.json", () => {
   const dir = makeTempDir("signals-turbo");
-  t.after(() => cleanup(dir));
-
-  writeFileSync(join(dir, "package.json"), JSON.stringify({ name: "test" }), "utf-8");
-  writeFileSync(join(dir, "turbo.json"), "{}", "utf-8");
-  const signals = detectProjectSignals(dir);
-  assert.equal(signals.isMonorepo, true);
+  try {
+    writeFileSync(join(dir, "package.json"), JSON.stringify({ name: "test" }), "utf-8");
+    writeFileSync(join(dir, "turbo.json"), "{}", "utf-8");
+    const signals = detectProjectSignals(dir);
+    assert.equal(signals.isMonorepo, true);
+  } finally {
+    cleanup(dir);
+  }
 });
 
-test("detectProjectSignals: CI detection", (t) => {
+test("detectProjectSignals: CI detection", () => {
   const dir = makeTempDir("signals-ci");
-  t.after(() => cleanup(dir));
-
-  mkdirSync(join(dir, ".github", "workflows"), { recursive: true });
-  const signals = detectProjectSignals(dir);
-  assert.equal(signals.hasCI, true);
+  try {
+    mkdirSync(join(dir, ".github", "workflows"), { recursive: true });
+    const signals = detectProjectSignals(dir);
+    assert.equal(signals.hasCI, true);
+  } finally {
+    cleanup(dir);
+  }
 });
 
-test("detectProjectSignals: test detection via jest config", (t) => {
+test("detectProjectSignals: test detection via jest config", () => {
   const dir = makeTempDir("signals-tests");
-  t.after(() => cleanup(dir));
-
-  writeFileSync(join(dir, "jest.config.ts"), "export default {}", "utf-8");
-  const signals = detectProjectSignals(dir);
-  assert.equal(signals.hasTests, true);
+  try {
+    writeFileSync(join(dir, "jest.config.ts"), "export default {}", "utf-8");
+    const signals = detectProjectSignals(dir);
+    assert.equal(signals.hasTests, true);
+  } finally {
+    cleanup(dir);
+  }
 });
 
-test("detectProjectSignals: package manager detection", (t) => {
+test("detectProjectSignals: package manager detection", () => {
   const dir1 = makeTempDir("pm-pnpm");
   const dir2 = makeTempDir("pm-yarn");
   const dir3 = makeTempDir("pm-bun");
-  t.after(() => {
+  try {
+    writeFileSync(join(dir1, "pnpm-lock.yaml"), "", "utf-8");
+    writeFileSync(join(dir1, "package.json"), "{}", "utf-8");
+    assert.equal(detectProjectSignals(dir1).packageManager, "pnpm");
+
+    writeFileSync(join(dir2, "yarn.lock"), "", "utf-8");
+    writeFileSync(join(dir2, "package.json"), "{}", "utf-8");
+    assert.equal(detectProjectSignals(dir2).packageManager, "yarn");
+
+    writeFileSync(join(dir3, "bun.lockb"), "", "utf-8");
+    writeFileSync(join(dir3, "package.json"), "{}", "utf-8");
+    assert.equal(detectProjectSignals(dir3).packageManager, "bun");
+  } finally {
     cleanup(dir1);
     cleanup(dir2);
     cleanup(dir3);
-  });
-
-  writeFileSync(join(dir1, "pnpm-lock.yaml"), "", "utf-8");
-  writeFileSync(join(dir1, "package.json"), "{}", "utf-8");
-  assert.equal(detectProjectSignals(dir1).packageManager, "pnpm");
-
-  writeFileSync(join(dir2, "yarn.lock"), "", "utf-8");
-  writeFileSync(join(dir2, "package.json"), "{}", "utf-8");
-  assert.equal(detectProjectSignals(dir2).packageManager, "yarn");
-
-  writeFileSync(join(dir3, "bun.lockb"), "", "utf-8");
-  writeFileSync(join(dir3, "package.json"), "{}", "utf-8");
-  assert.equal(detectProjectSignals(dir3).packageManager, "bun");
+  }
 });
 
-test("detectProjectSignals: skips default npm test script", (t) => {
+test("detectProjectSignals: skips default npm test script", () => {
   const dir = makeTempDir("signals-default-test");
-  t.after(() => cleanup(dir));
-
-  writeFileSync(
-    join(dir, "package.json"),
-    JSON.stringify({
-      name: "test",
-      scripts: { test: 'echo "Error: no test specified" && exit 1' },
-    }),
-    "utf-8",
-  );
-  const signals = detectProjectSignals(dir);
-  // Should NOT include the default npm test script
-  assert.equal(
-    signals.verificationCommands.some(c => c.includes("test")),
-    false,
-  );
+  try {
+    writeFileSync(
+      join(dir, "package.json"),
+      JSON.stringify({
+        name: "test",
+        scripts: { test: 'echo "Error: no test specified" && exit 1' },
+      }),
+      "utf-8",
+    );
+    const signals = detectProjectSignals(dir);
+    // Should NOT include the default npm test script
+    assert.equal(
+      signals.verificationCommands.some(c => c.includes("test")),
+      false,
+    );
+  } finally {
+    cleanup(dir);
+  }
 });
 
-test("detectProjectSignals: pnpm uses pnpm commands", (t) => {
+test("detectProjectSignals: pnpm uses pnpm commands", () => {
   const dir = makeTempDir("signals-pnpm-cmds");
-  t.after(() => cleanup(dir));
-
-  writeFileSync(
-    join(dir, "package.json"),
-    JSON.stringify({
-      name: "test",
-      scripts: { test: "vitest", build: "tsc" },
-    }),
-    "utf-8",
-  );
-  writeFileSync(join(dir, "pnpm-lock.yaml"), "", "utf-8");
-  const signals = detectProjectSignals(dir);
-  assert.ok(signals.verificationCommands.includes("pnpm test"));
-  assert.ok(signals.verificationCommands.includes("pnpm run build"));
+  try {
+    writeFileSync(
+      join(dir, "package.json"),
+      JSON.stringify({
+        name: "test",
+        scripts: { test: "vitest", build: "tsc" },
+      }),
+      "utf-8",
+    );
+    writeFileSync(join(dir, "pnpm-lock.yaml"), "", "utf-8");
+    const signals = detectProjectSignals(dir);
+    assert.ok(signals.verificationCommands.includes("pnpm test"));
+    assert.ok(signals.verificationCommands.includes("pnpm run build"));
+  } finally {
+    cleanup(dir);
+  }
 });
 
-test("detectProjectSignals: Ruby project with rspec", (t) => {
+test("detectProjectSignals: Ruby project with rspec", () => {
   const dir = makeTempDir("signals-ruby");
-  t.after(() => cleanup(dir));
-
-  writeFileSync(join(dir, "Gemfile"), 'source "https://rubygems.org"\n', "utf-8");
-  mkdirSync(join(dir, "spec"), { recursive: true });
-  const signals = detectProjectSignals(dir);
-  assert.ok(signals.detectedFiles.includes("Gemfile"));
-  assert.equal(signals.primaryLanguage, "ruby");
-  assert.ok(signals.verificationCommands.includes("bundle exec rspec"));
+  try {
+    writeFileSync(join(dir, "Gemfile"), 'source "https://rubygems.org"\n', "utf-8");
+    mkdirSync(join(dir, "spec"), { recursive: true });
+    const signals = detectProjectSignals(dir);
+    assert.ok(signals.detectedFiles.includes("Gemfile"));
+    assert.equal(signals.primaryLanguage, "ruby");
+    assert.ok(signals.verificationCommands.includes("bundle exec rspec"));
+  } finally {
+    cleanup(dir);
+  }
 });
 
-test("detectProjectSignals: Makefile with test target", (t) => {
+test("detectProjectSignals: Makefile with test target", () => {
   const dir = makeTempDir("signals-make");
-  t.after(() => cleanup(dir));
-
-  writeFileSync(join(dir, "Makefile"), "test:\n\tgo test ./...\n\nbuild:\n\tgo build\n", "utf-8");
-  const signals = detectProjectSignals(dir);
-  assert.ok(signals.detectedFiles.includes("Makefile"));
-  assert.ok(signals.verificationCommands.includes("make test"));
+  try {
+    writeFileSync(join(dir, "Makefile"), "test:\n\tgo test ./...\n\nbuild:\n\tgo build\n", "utf-8");
+    const signals = detectProjectSignals(dir);
+    assert.ok(signals.detectedFiles.includes("Makefile"));
+    assert.ok(signals.verificationCommands.includes("make test"));
+  } finally {
+    cleanup(dir);
+  }
 });