rebar-mcp 2.0.0

package/src/tests/knowledge.test.ts

@@ -0,0 +1,371 @@
+/**
+ * Integration tests for Rebar knowledge tools
+ * rebar_create_knowledge, rebar_create_adr
+ */
+import { describe, it, before } from "node:test";
+import * as assert from "node:assert";
+import {
+  createTestDir,
+  createMockProject,
+  readTestFile,
+  testFileExists,
+  assertToolSuccess,
+  assertToolError,
+  getToolResultText,
+  parseToolResultJson,
+} from "./test-utils.js";
+import { initializeTools, invokeTool } from "./tool-harness.js";
+
+// Initialize tools before all tests
+before(() => {
+  initializeTools();
+});
+
+describe("rebar_create_knowledge", () => {
+  it("should create a knowledge document in the correct category directory", async () => {
+    const { path: testDir, cleanup } = await createTestDir();
+
+    try {
+      const originalCwd = process.cwd();
+      process.chdir(testDir);
+
+      try {
+        await createMockProject(testDir);
+
+        const result = await invokeTool("rebar_create_knowledge", {
+          title: "API Design Guidelines",
+          category: "api",
+          content: "## REST Conventions\n\nUse proper HTTP methods.",
+          tags: ["api", "rest", "conventions"],
+        });
+
+        assertToolSuccess(result);
+
+        assert.ok(
+          await testFileExists(testDir, ".claude/docs/api/api-design-guidelines.md"),
+          "Knowledge doc should be created in api category"
+        );
+
+        const doc = await readTestFile(
+          testDir,
+          ".claude/docs/api/api-design-guidelines.md"
+        );
+        assert.ok(doc, "Document should have content");
+        assert.ok(doc.includes("title: API Design Guidelines"), "Should have title in frontmatter");
+        assert.ok(doc.includes("category: api"), "Should have category in frontmatter");
+        assert.ok(doc.includes("tags: [api, rest, conventions]"), "Should have tags");
+        assert.ok(doc.includes("## REST Conventions"), "Should include content");
+      } finally {
+        process.chdir(originalCwd);
+      }
+    } finally {
+      await cleanup();
+    }
+  });
+
+  it("should fail if document with same title already exists", async () => {
+    const { path: testDir, cleanup } = await createTestDir();
+
+    try {
+      const originalCwd = process.cwd();
+      process.chdir(testDir);
+
+      try {
+        await createMockProject(testDir);
+
+        // Create first document
+        await invokeTool("rebar_create_knowledge", {
+          title: "Duplicate Doc",
+          category: "runbook",
+          content: "First version",
+        });
+
+        // Try to create duplicate
+        const result = await invokeTool("rebar_create_knowledge", {
+          title: "Duplicate Doc",
+          category: "runbook",
+          content: "Second version",
+        });
+
+        assertToolError(result);
+        const text = getToolResultText(result);
+        assert.ok(text.includes("already exists"), "Should mention already exists");
+      } finally {
+        process.chdir(originalCwd);
+      }
+    } finally {
+      await cleanup();
+    }
+  });
+
+  it("should support dry_run mode", async () => {
+    const { path: testDir, cleanup } = await createTestDir();
+
+    try {
+      const originalCwd = process.cwd();
+      process.chdir(testDir);
+
+      try {
+        await createMockProject(testDir);
+
+        const result = await invokeTool("rebar_create_knowledge", {
+          title: "Dry Run Doc",
+          category: "schema",
+          content: "Schema definition",
+          dry_run: true,
+          output_format: "json",
+        });
+
+        assertToolSuccess(result);
+
+        const parsed = parseToolResultJson<Record<string, unknown>>(result);
+        assert.strictEqual(parsed.dry_run, true);
+
+        // File should not exist
+        assert.ok(
+          !(await testFileExists(testDir, ".claude/docs/schema/dry-run-doc.md")),
+          "Document should NOT be created in dry-run"
+        );
+      } finally {
+        process.chdir(originalCwd);
+      }
+    } finally {
+      await cleanup();
+    }
+  });
+
+  it("should create docs in all supported categories", async () => {
+    const { path: testDir, cleanup } = await createTestDir();
+
+    try {
+      const originalCwd = process.cwd();
+      process.chdir(testDir);
+
+      try {
+        await createMockProject(testDir);
+
+        const categories = ["adr", "runbook", "api", "schema", "style"] as const;
+
+        for (const category of categories) {
+          const result = await invokeTool("rebar_create_knowledge", {
+            title: `Test ${category} doc`,
+            category,
+            content: `Content for ${category}`,
+          });
+
+          assertToolSuccess(result);
+          assert.ok(
+            await testFileExists(testDir, `.claude/docs/${category}/test-${category}-doc.md`),
+            `Document should be created in ${category} category`
+          );
+        }
+      } finally {
+        process.chdir(originalCwd);
+      }
+    } finally {
+      await cleanup();
+    }
+  });
+});
+
+describe("rebar_create_adr", () => {
+  it("should create an ADR with proper numbering", async () => {
+    const { path: testDir, cleanup } = await createTestDir();
+
+    try {
+      const originalCwd = process.cwd();
+      process.chdir(testDir);
+
+      try {
+        await createMockProject(testDir);
+
+        const result = await invokeTool("rebar_create_adr", {
+          title: "Use PostgreSQL for persistence",
+          status: "accepted",
+          context: "We need a reliable RDBMS for our application data.",
+          decision: "Use PostgreSQL with Prisma ORM.",
+          consequences: "Need to manage migrations. Get ACID compliance.",
+        });
+
+        assertToolSuccess(result);
+
+        // Should be numbered 0001
+        assert.ok(
+          await testFileExists(testDir, ".claude/docs/adr/0001-use-postgresql-for-persistence.md"),
+          "ADR should be created with 0001 prefix"
+        );
+
+        const adr = await readTestFile(
+          testDir,
+          ".claude/docs/adr/0001-use-postgresql-for-persistence.md"
+        );
+        assert.ok(adr, "ADR should have content");
+        assert.ok(adr.includes("# ADR 0001:"), "Should have ADR number in title");
+        assert.ok(adr.includes("**Status:** accepted"), "Should have status");
+        assert.ok(adr.includes("## Context"), "Should have Context section");
+        assert.ok(adr.includes("## Decision"), "Should have Decision section");
+        assert.ok(adr.includes("## Consequences"), "Should have Consequences section");
+      } finally {
+        process.chdir(originalCwd);
+      }
+    } finally {
+      await cleanup();
+    }
+  });
+
+  it("should auto-increment ADR numbers", async () => {
+    const { path: testDir, cleanup } = await createTestDir();
+
+    try {
+      const originalCwd = process.cwd();
+      process.chdir(testDir);
+
+      try {
+        await createMockProject(testDir);
+
+        // Create first ADR
+        await invokeTool("rebar_create_adr", {
+          title: "First Decision",
+          status: "accepted",
+          context: "Context 1",
+          decision: "Decision 1",
+          consequences: "Consequences 1",
+        });
+
+        // Create second ADR
+        const result = await invokeTool("rebar_create_adr", {
+          title: "Second Decision",
+          status: "proposed",
+          context: "Context 2",
+          decision: "Decision 2",
+          consequences: "Consequences 2",
+        });
+
+        assertToolSuccess(result);
+
+        // Should be numbered 0002
+        assert.ok(
+          await testFileExists(testDir, ".claude/docs/adr/0002-second-decision.md"),
+          "Second ADR should be 0002"
+        );
+      } finally {
+        process.chdir(originalCwd);
+      }
+    } finally {
+      await cleanup();
+    }
+  });
+
+  it("should support all status types", async () => {
+    const { path: testDir, cleanup } = await createTestDir();
+
+    try {
+      const originalCwd = process.cwd();
+      process.chdir(testDir);
+
+      try {
+        await createMockProject(testDir);
+
+        const statuses = ["proposed", "accepted", "deprecated"] as const;
+
+        for (let i = 0; i < statuses.length; i++) {
+          const status = statuses[i];
+          const result = await invokeTool("rebar_create_adr", {
+            title: `ADR with ${status} status`,
+            status,
+            context: "Test context",
+            decision: "Test decision",
+            consequences: "Test consequences",
+          });
+
+          assertToolSuccess(result);
+
+          const num = String(i + 1).padStart(4, "0");
+          const adr = await readTestFile(
+            testDir,
+            `.claude/docs/adr/${num}-adr-with-${status}-status.md`
+          );
+          assert.ok(adr?.includes(`**Status:** ${status}`), `Should have ${status} status`);
+        }
+      } finally {
+        process.chdir(originalCwd);
+      }
+    } finally {
+      await cleanup();
+    }
+  });
+
+  it("should support dry_run mode", async () => {
+    const { path: testDir, cleanup } = await createTestDir();
+
+    try {
+      const originalCwd = process.cwd();
+      process.chdir(testDir);
+
+      try {
+        await createMockProject(testDir);
+
+        const result = await invokeTool("rebar_create_adr", {
+          title: "Dry Run ADR",
+          status: "proposed",
+          context: "Test",
+          decision: "Test",
+          consequences: "Test",
+          dry_run: true,
+          output_format: "json",
+        });
+
+        assertToolSuccess(result);
+
+        const parsed = parseToolResultJson<Record<string, unknown>>(result);
+        assert.strictEqual(parsed.dry_run, true);
+
+        // File should not exist
+        assert.ok(
+          !(await testFileExists(testDir, ".claude/docs/adr/0001-dry-run-adr.md")),
+          "ADR should NOT be created in dry-run"
+        );
+      } finally {
+        process.chdir(originalCwd);
+      }
+    } finally {
+      await cleanup();
+    }
+  });
+
+  it("should return JSON output when requested", async () => {
+    const { path: testDir, cleanup } = await createTestDir();
+
+    try {
+      const originalCwd = process.cwd();
+      process.chdir(testDir);
+
+      try {
+        await createMockProject(testDir);
+
+        const result = await invokeTool("rebar_create_adr", {
+          title: "JSON Output Test",
+          status: "accepted",
+          context: "Test",
+          decision: "Test",
+          consequences: "Test",
+          output_format: "json",
+        });
+
+        assertToolSuccess(result);
+
+        const parsed = parseToolResultJson<Record<string, unknown>>(result);
+        assert.strictEqual(parsed.success, true);
+        assert.strictEqual(parsed.operation, "create_adr");
+
+        const data = parsed.data as Record<string, unknown>;
+        assert.strictEqual(data.number, "0001");
+        assert.strictEqual(data.status, "accepted");
+      } finally {
+        process.chdir(originalCwd);
+      }
+    } finally {
+      await cleanup();
+    }
+  });
+});