rebar-mcp 2.0.0

package/src/tests/test-utils.ts

@@ -0,0 +1,206 @@
+/**
+ * Test utilities for rebar-mcp-server integration tests
+ * Provides mock filesystem and helper functions
+ */
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import * as os from "node:os";
+import * as crypto from "node:crypto";
+
+/**
+ * Creates an isolated temporary directory for testing
+ * Returns cleanup function to remove it after test
+ */
+export async function createTestDir(): Promise<{
+  path: string;
+  cleanup: () => Promise<void>;
+}> {
+  const tmpBase = os.tmpdir();
+  const dirName = `rebar-test-${crypto.randomBytes(8).toString("hex")}`;
+  const testDir = path.join(tmpBase, dirName);
+
+  await fs.mkdir(testDir, { recursive: true });
+
+  return {
+    path: testDir,
+    cleanup: async () => {
+      await fs.rm(testDir, { recursive: true, force: true });
+    },
+  };
+}
+
+/**
+ * Creates a mock project structure for testing
+ */
+export async function createMockProject(
+  testDir: string,
+  options: {
+    packageJson?: Record<string, unknown>;
+    existingClaudeMd?: string;
+    existingSettings?: Record<string, unknown>;
+    techStack?: "node" | "python" | "rust" | "go";
+  } = {}
+): Promise<void> {
+  const { packageJson, existingClaudeMd, existingSettings, techStack = "node" } = options;
+
+  // Create package.json or equivalent based on tech stack
+  if (techStack === "node") {
+    const pkg = packageJson ?? {
+      name: "test-project",
+      version: "1.0.0",
+      scripts: {
+        build: "tsc",
+        test: "jest",
+        lint: "eslint .",
+      },
+      dependencies: {
+        express: "^4.18.0",
+      },
+      devDependencies: {
+        typescript: "^5.0.0",
+        jest: "^29.0.0",
+      },
+    };
+    await fs.writeFile(
+      path.join(testDir, "package.json"),
+      JSON.stringify(pkg, null, 2)
+    );
+  } else if (techStack === "python") {
+    await fs.writeFile(
+      path.join(testDir, "pyproject.toml"),
+      `[project]\nname = "test-project"\nversion = "1.0.0"\n`
+    );
+  } else if (techStack === "rust") {
+    await fs.writeFile(
+      path.join(testDir, "Cargo.toml"),
+      `[package]\nname = "test-project"\nversion = "1.0.0"\n`
+    );
+  } else if (techStack === "go") {
+    await fs.writeFile(
+      path.join(testDir, "go.mod"),
+      `module test-project\n\ngo 1.21\n`
+    );
+  }
+
+  // Create src directory
+  await fs.mkdir(path.join(testDir, "src"), { recursive: true });
+  await fs.writeFile(path.join(testDir, "src", "index.ts"), "// test file\n");
+
+  // Create existing CLAUDE.md if specified
+  if (existingClaudeMd) {
+    await fs.writeFile(path.join(testDir, "CLAUDE.md"), existingClaudeMd);
+  }
+
+  // Create .claude directory structure if settings provided
+  if (existingSettings) {
+    await fs.mkdir(path.join(testDir, ".claude"), { recursive: true });
+    await fs.writeFile(
+      path.join(testDir, ".claude", "settings.json"),
+      JSON.stringify(existingSettings, null, 2)
+    );
+  }
+}
+
+/**
+ * Reads a file from test directory, returns null if not found
+ */
+export async function readTestFile(testDir: string, relativePath: string): Promise<string | null> {
+  try {
+    return await fs.readFile(path.join(testDir, relativePath), "utf-8");
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Checks if a file exists in test directory
+ */
+export async function testFileExists(testDir: string, relativePath: string): Promise<boolean> {
+  try {
+    await fs.access(path.join(testDir, relativePath));
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Parses JSON from a test file
+ */
+export async function readTestJson<T = unknown>(testDir: string, relativePath: string): Promise<T | null> {
+  const content = await readTestFile(testDir, relativePath);
+  if (!content) return null;
+  try {
+    return JSON.parse(content) as T;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Creates a minimal valid CLAUDE.md for testing
+ */
+export function createMinimalClaudeMd(): string {
+  return `# Test Project
+
+## Tech Stack
+- Node.js
+
+## Build & Test
+\`\`\`bash
+npm run build
+npm test
+\`\`\`
+`;
+}
+
+/**
+ * Creates a minimal valid skill for testing
+ */
+export function createMinimalSkill(name: string, description: string): string {
+  return `---
+name: ${name}
+description: ${description}
+invocation: user
+context: inline
+---
+
+# ${name}
+
+${description}
+`;
+}
+
+/**
+ * Asserts tool result is successful
+ */
+export function assertToolSuccess(result: { content: Array<{ type: string; text: string }>; isError?: boolean }): void {
+  if (result.isError) {
+    const text = result.content[0]?.text ?? "Unknown error";
+    throw new Error(`Tool returned error: ${text}`);
+  }
+}
+
+/**
+ * Asserts tool result is an error
+ */
+export function assertToolError(result: { content: Array<{ type: string; text: string }>; isError?: boolean }): void {
+  if (!result.isError) {
+    throw new Error("Expected tool to return error, but it succeeded");
+  }
+}
+
+/**
+ * Gets text content from tool result
+ */
+export function getToolResultText(result: { content: Array<{ type: string; text: string }> }): string {
+  return result.content[0]?.text ?? "";
+}
+
+/**
+ * Parses JSON output from tool result
+ */
+export function parseToolResultJson<T = unknown>(result: { content: Array<{ type: string; text: string }> }): T {
+  const text = getToolResultText(result);
+  return JSON.parse(text) as T;
+}

package/src/tests/tool-harness.ts

@@ -0,0 +1,70 @@
+/**
+ * Tool Harness for Integration Testing
+ * Creates a minimal MCP server and provides a way to invoke tools directly
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { registerScaffoldingTools } from "../tools/scaffolding.js";
+import { registerKnowledgeTools } from "../tools/knowledge.js";
+import { registerManagementTools } from "../tools/management.js";
+import { registerEnterpriseTools } from "../tools/enterprise.js";
+import type { ToolResult } from "../types.js";
+
+// Store registered tools for direct invocation
+const toolRegistry = new Map<string, (args: Record<string, unknown>) => Promise<ToolResult>>();
+
+/**
+ * Mock MCP Server that captures tool registrations
+ */
+function createMockServer(): McpServer {
+  // Create a minimal mock that captures tool registrations
+  const mockServer = {
+    registerTool: (
+      name: string,
+      _options: unknown,
+      handler: (args: Record<string, unknown>) => Promise<ToolResult>
+    ) => {
+      toolRegistry.set(name, handler);
+    },
+  } as unknown as McpServer;
+
+  return mockServer;
+}
+
+/**
+ * Initialize all tools for testing
+ */
+export function initializeTools(): void {
+  const server = createMockServer();
+  registerScaffoldingTools(server);
+  registerKnowledgeTools(server);
+  registerManagementTools(server);
+  registerEnterpriseTools(server);
+}
+
+/**
+ * Invoke a tool by name with arguments
+ */
+export async function invokeTool(
+  name: string,
+  args: Record<string, unknown>
+): Promise<ToolResult> {
+  const handler = toolRegistry.get(name);
+  if (!handler) {
+    throw new Error(`Tool not found: ${name}. Available tools: ${Array.from(toolRegistry.keys()).join(", ")}`);
+  }
+  return handler(args);
+}
+
+/**
+ * Get list of registered tool names
+ */
+export function getRegisteredTools(): string[] {
+  return Array.from(toolRegistry.keys());
+}
+
+/**
+ * Check if a tool is registered
+ */
+export function isToolRegistered(name: string): boolean {
+  return toolRegistry.has(name);
+}