@skyramp/mcp 0.2.8 → 0.2.150-rc.local.de

package/build/tools/enrichTestWithMocksTool.d.ts

@@ -0,0 +1,15 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { ProgrammingLanguage } from "../types/TestTypes.js";
+/**
+ * skyramp_enrich_test_with_mocks
+ *
+ * Injects mock imports and apply_mock() calls into a generated test file.
+ * The mock files are generated by skyramp_mock_generation — this tool wires
+ * them into the test so the mocks are applied before the test runs.
+ *
+ * No data duplication — the test imports from the generated mock files.
+ */
+export declare function registerEnrichTestWithMocksTool(server: McpServer): void;
+declare function injectMockImports(original: string, testFile: string, scenarioName: string, mockFiles: string[], traceComments?: string[], language?: ProgrammingLanguage): string;
+declare function buildMockImportBlock(testFile: string, scenarioName: string, mockFiles: string[], traceComments?: string[], language?: ProgrammingLanguage): string;
+export { injectMockImports, buildMockImportBlock };

package/build/tools/enrichTestWithMocksTool.js

@@ -0,0 +1,414 @@
+import { z } from "zod";
+import { logger } from "../utils/logger.js";
+import * as fs from "fs";
+import * as path from "path";
+import { ProgrammingLanguage, MockProtocol } from "../types/TestTypes.js";
+const TOOL_NAME = "skyramp_enrich_test_with_mocks";
+const enrichSchema = {
+    testFile: z
+        .string()
+        .describe("Absolute path to the generated test file to enrich (e.g., /repo/tests/skyramp/order_happy_path_integration_test.py)"),
+    scenarioName: z
+        .string()
+        .describe("Human-readable scenario name (e.g., order-happy-path, payment-timeout). Used as the SCENARIO_NAME constant."),
+    mockFiles: z
+        .array(z.string())
+        .describe("Absolute paths to the generated mock files (from skyramp_mock_generation) that this test needs. " +
+        "The tool will inject import statements and apply_mock() calls for each file. " +
+        'Example: ["/repo/tests/skyramp/mocks/validate_POST_mock.py", "/repo/tests/skyramp/mocks/payment_authorizations_POST_mock.py"]'),
+    language: z
+        .nativeEnum(ProgrammingLanguage)
+        .optional()
+        .describe("Programming language of the generated test. Optional for backward compatibility; inferred from testFile when omitted. Mock enrichment currently supports Python tests only."),
+    traceComments: z
+        .array(z.string())
+        .optional()
+        .describe("Optional trace comments showing how mock values flow to assertions (e.g., 'pricing-service returns discount=true → creator sets order.discount_applied=true → assert True')"),
+};
+/**
+ * skyramp_enrich_test_with_mocks
+ *
+ * Injects mock imports and apply_mock() calls into a generated test file.
+ * The mock files are generated by skyramp_mock_generation — this tool wires
+ * them into the test so the mocks are applied before the test runs.
+ *
+ * No data duplication — the test imports from the generated mock files.
+ */
+export function registerEnrichTestWithMocksTool(server) {
+    server.registerTool(TOOL_NAME, {
+        description: "Enrich a generated INTEGRATION test file by injecting imports from generated mock files. " +
+            "Call this after skyramp_mock_generation and skyramp_integration_test_generation. " +
+            "The tool adds import statements and apply_mock() calls so the test uses the " +
+            "generated mocks directly — no data duplication. " +
+            "NOTE: Do NOT call this for contract tests — consumer contract tests already have mocks wired inline by the generation tool.",
+        inputSchema: enrichSchema,
+    }, async (params) => {
+        try {
+            const { testFile, scenarioName, mockFiles, traceComments, language } = params;
+            if (!fs.existsSync(testFile)) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `**Error:** Test file not found: ${testFile}`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            // Validate mock files exist
+            const missingFiles = mockFiles.filter((f) => !fs.existsSync(f));
+            if (missingFiles.length > 0) {
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `**Error:** Mock files not found:\n` +
+                                missingFiles.map((f) => `  - ${f}`).join("\n") +
+                                `\n\nGenerate them first with \`skyramp_mock_generation\`.`,
+                        },
+                    ],
+                    isError: true,
+                };
+            }
+            const resolvedLanguage = resolveMockEnrichmentLanguage(testFile, language);
+            if (resolvedLanguage !== ProgrammingLanguage.PYTHON) {
+                return unsupportedLanguageResult(testFile, resolvedLanguage);
+            }
+            const original = fs.readFileSync(testFile, "utf-8");
+            const enriched = injectMockImports(original, testFile, scenarioName, mockFiles, traceComments, resolvedLanguage);
+            fs.writeFileSync(testFile, enriched);
+            logger.info(`Enriched test file with mock imports: ${testFile}`, {
+                scenarioName,
+                mockFileCount: mockFiles.length,
+            });
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: [
+                            `**Test enriched with mock imports for scenario "${scenarioName}".**\n`,
+                            `**File:** ${testFile}`,
+                            `**Mock files imported:** ${mockFiles.length}`,
+                            ...mockFiles.map((f) => `  • ${path.basename(f)}`),
+                            `\nThe test now imports and applies mocks from the generated files.`,
+                            `Before execution, stop real services selected for mocking, then execute with: \`skyramp_execute_test({testFile: "${testFile}", mockIsolationConfirmed: true, ...})\``,
+                        ].join("\n"),
+                    },
+                ],
+            };
+        }
+        catch (error) {
+            logger.error(`Failed to enrich test: ${error.message}`);
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `**Failed to enrich test:** ${error.message}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+    });
+}
+// ── Helpers ──────────────────────────────────────────────────────────────────
+function injectMockImports(original, testFile, scenarioName, mockFiles, traceComments, language) {
+    const resolvedLanguage = resolveMockEnrichmentLanguage(testFile, language);
+    assertSupportedMockEnrichmentLanguage(testFile, resolvedLanguage);
+    const generatedBlock = buildMockImportBlock(testFile, scenarioName, mockFiles, traceComments, resolvedLanguage);
+    const existingBlockRange = findGeneratedMockBlockRange(original);
+    if (existingBlockRange) {
+        const suffix = original.slice(existingBlockRange.end);
+        const separator = suffix.length > 0 && !suffix.startsWith("\n") ? "\n" : "";
+        original =
+            original.slice(0, existingBlockRange.start) +
+                generatedBlock +
+                separator +
+                suffix;
+    }
+    // Find insertion point: after the last import line
+    const lines = original.split("\n");
+    let insertIdx = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i].trim();
+        if (line.startsWith("import ") ||
+            line.startsWith("from ") ||
+            line.startsWith("# Import") ||
+            (line === "" &&
+                i > 0 &&
+                (lines[i - 1].trim().startsWith("import") ||
+                    lines[i - 1].trim().startsWith("from")))) {
+            insertIdx = i + 1;
+        }
+    }
+    // If no imports found, insert after initial comments
+    if (insertIdx === 0) {
+        for (let i = 0; i < lines.length; i++) {
+            if (!lines[i].startsWith("#") && lines[i].trim() !== "") {
+                insertIdx = i;
+                break;
+            }
+        }
+    }
+    // Insert the mock block once. If a previous generated block existed, it was
+    // replaced before splitting into lines so stale imports/mappings do not survive.
+    if (!existingBlockRange) {
+        lines.splice(insertIdx, 0, "", generatedBlock, "");
+    }
+    // Wire apply_all_mocks(client) after the generated Skyramp client exists.
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // Match Python test function definitions (def test_integration(): or def test_*():)
+        if (/^def test_\w+\(/.test(line.trim())) {
+            const functionEnd = findPythonFunctionEnd(lines, i + 1);
+            const applyCallIndex = lines.findIndex((l, idx) => idx >= i &&
+                idx < functionEnd &&
+                (l.trim() === "apply_all_mocks(client)" ||
+                    l.trim() === "apply_all_mocks()"));
+            if (applyCallIndex !== -1) {
+                // Existing generated tests may already call apply_all_mocks(client).
+            }
+            else {
+                const clientEnd = findSkyrampClientConstructionEnd(lines, i + 1, functionEnd);
+                if (clientEnd !== -1) {
+                    lines.splice(clientEnd + 1, 0, "    apply_all_mocks(client)", "");
+                }
+            }
+            break; // Only inject into the first test function
+        }
+    }
+    return lines.join("\n");
+}
+function resolveMockEnrichmentLanguage(testFile, language) {
+    if (language)
+        return language;
+    const extension = path.extname(testFile).toLowerCase();
+    switch (extension) {
+        case ".py":
+            return ProgrammingLanguage.PYTHON;
+        case ".ts":
+        case ".tsx":
+            return ProgrammingLanguage.TYPESCRIPT;
+        case ".js":
+        case ".jsx":
+            return ProgrammingLanguage.JAVASCRIPT;
+        case ".java":
+            return ProgrammingLanguage.JAVA;
+        default:
+            throw new Error(`Cannot infer mock enrichment language from test file extension: ${testFile}`);
+    }
+}
+function assertSupportedMockEnrichmentLanguage(testFile, language) {
+    if (language === ProgrammingLanguage.PYTHON)
+        return;
+    throw new Error(unsupportedLanguageMessage(testFile, language));
+}
+function unsupportedLanguageMessage(testFile, language) {
+    return `Mock enrichment is currently supported only for Python tests; received language "${language}" for test file "${testFile}".`;
+}
+function unsupportedLanguageResult(testFile, language) {
+    return {
+        content: [
+            {
+                type: "text",
+                text: `**Error:** ${unsupportedLanguageMessage(testFile, language)}`,
+            },
+        ],
+        isError: true,
+    };
+}
+function findGeneratedMockBlockRange(source) {
+    const marker = "# ─── Mock Scenario:";
+    const start = source.indexOf(marker);
+    if (start === -1)
+        return null;
+    const segment = source.slice(start);
+    const lines = segment.split("\n");
+    const applyIdx = lines.findIndex((line) => line.trim() === "def apply_all_mocks(client):");
+    if (applyIdx === -1)
+        return null;
+    let endLine = lines.length;
+    for (let i = applyIdx + 1; i < lines.length; i++) {
+        const line = lines[i];
+        if (line.trim() === "" || /^\s/.test(line))
+            continue;
+        endLine = i;
+        break;
+    }
+    while (endLine < lines.length) {
+        const line = lines[endLine].trim();
+        if (line === "" || line.startsWith("# Mock trace:")) {
+            endLine += 1;
+            continue;
+        }
+        break;
+    }
+    const replacementText = lines.slice(0, endLine).join("\n");
+    return { start, end: start + replacementText.length };
+}
+function findPythonFunctionEnd(lines, bodyStart) {
+    for (let i = bodyStart; i < lines.length; i++) {
+        if (/^def\s+\w+\(/.test(lines[i]) || /^class\s+\w+/.test(lines[i])) {
+            return i;
+        }
+    }
+    return lines.length;
+}
+function findSkyrampClientConstructionEnd(lines, start, end) {
+    for (let i = start; i < end; i++) {
+        if (!/^\s*client\s*=\s*skyramp\.Client\s*\(/.test(lines[i])) {
+            continue;
+        }
+        let depth = 0;
+        for (let j = i; j < end; j++) {
+            depth += countChar(lines[j], "(") - countChar(lines[j], ")");
+            if (depth <= 0) {
+                return j;
+            }
+        }
+        return i;
+    }
+    return -1;
+}
+function countChar(value, char) {
+    return [...value].filter((current) => current === char).length;
+}
+function buildMockImportBlock(testFile, scenarioName, mockFiles, traceComments, language) {
+    const resolvedLanguage = resolveMockEnrichmentLanguage(testFile, language);
+    assertSupportedMockEnrichmentLanguage(testFile, resolvedLanguage);
+    const lines = [];
+    const testDir = path.dirname(testFile);
+    lines.push(`# ─── Mock Scenario: ${scenarioName} ──────────────────────────────────────`);
+    lines.push(`SCENARIO_NAME = "${scenarioName}"`);
+    lines.push(``);
+    // Generate path-based mock module loaders so dotted filenames still import correctly.
+    const mockEntries = [];
+    const usedModuleNames = new Set();
+    for (const mockFile of mockFiles) {
+        const relativePath = path.relative(testDir, mockFile).replace(/\\/g, "/");
+        const baseName = path.basename(mockFile, ".py");
+        const moduleName = uniquePythonIdentifier(baseName, usedModuleNames);
+        const serviceName = baseName.replace(/_mock$/, "").replace(/_/g, "-");
+        // Read each mock file once for both URL and protocol extraction.
+        const commandLine = extractMockCommandLine(mockFile);
+        const targetUrl = extractBaseUrlFromCommandLine(commandLine);
+        const protocol = extractProtocolFromCommandLine(commandLine, mockFile);
+        mockEntries.push({
+            serviceName,
+            moduleName,
+            relativePath,
+            targetUrl,
+            protocol,
+        });
+    }
+    lines.push(`import importlib.util`);
+    lines.push(`import os`);
+    lines.push(`from pathlib import Path`);
+    lines.push(``);
+    lines.push(`def _load_mock_factory(relative_path, module_name):`);
+    lines.push(`    mock_path = Path(__file__).parent / relative_path`);
+    lines.push(`    spec = importlib.util.spec_from_file_location(module_name, mock_path)`);
+    lines.push(`    if spec is None or spec.loader is None:`);
+    lines.push(`        raise ImportError(f"Could not load mock module: {mock_path}")`);
+    lines.push(`    module = importlib.util.module_from_spec(spec)`);
+    lines.push(`    spec.loader.exec_module(module)`);
+    lines.push(`    return module.get_all_mocks`);
+    // Generate MOCK_SERVICES dictionary
+    lines.push(``);
+    lines.push(`MOCK_SERVICES = {`);
+    for (const entry of mockEntries) {
+        lines.push(`    "${entry.serviceName}": {"factory": _load_mock_factory("${entry.relativePath}", "${entry.moduleName}"), "protocol": "${entry.protocol}"},`);
+    }
+    lines.push(`}`);
+    // Always define MOCK_TARGET_URLS so apply_all_mocks can reference it unconditionally.
+    // REST targets normalize to URL origins, while gRPC/Kafka targets preserve host:port.
+    lines.push(``);
+    lines.push(`MOCK_TARGET_URLS = {`);
+    for (const entry of mockEntries) {
+        if (entry.targetUrl) {
+            lines.push(`    "${entry.serviceName}": "${entry.targetUrl}",`);
+        }
+    }
+    lines.push(`}`);
+    // Generate apply_all_mocks() function.
+    lines.push(``);
+    lines.push(`def apply_all_mocks(client):`);
+    lines.push(`    """Apply all generated mocks together after protocol-specific normalization."""`);
+    lines.push(`    client.remove_all_mocks()`);
+    lines.push(``);
+    lines.push(`    all_mocks = []`);
+    lines.push(`    for service_name, mock_config in MOCK_SERVICES.items():`);
+    lines.push(`        get_mocks_fn = mock_config["factory"]`);
+    lines.push(`        mocks = get_mocks_fn()`);
+    lines.push(`        target_url = MOCK_TARGET_URLS.get(service_name)`);
+    lines.push(`        if target_url:`);
+    lines.push(`            for mock in mocks:`);
+    lines.push(`                mock.url = target_url`);
+    lines.push(`        all_mocks.extend(mocks)`);
+    lines.push(``);
+    lines.push(`    if all_mocks:`);
+    lines.push(`        client.apply_mock(all_mocks)`);
+    if (traceComments?.length) {
+        lines.push(``);
+        for (const comment of traceComments) {
+            lines.push(`# Mock trace: ${comment}`);
+        }
+    }
+    return lines.join("\n");
+}
+function extractMockCommandLine(mockFile) {
+    if (!fs.existsSync(mockFile))
+        return undefined;
+    return fs
+        .readFileSync(mockFile, "utf-8")
+        .split("\n")
+        .map((line) => line.replace(/^\s*#\s?/, "").trim())
+        .find((line) => line.startsWith("Command: skyramp generate mock "));
+}
+function extractProtocolFromCommandLine(commandLine, mockFile) {
+    const protocolMatch = commandLine?.match(/skyramp generate mock (rest|grpc|kafka)\b/);
+    if (protocolMatch?.[1])
+        return protocolMatch[1];
+    const baseName = path.basename(mockFile).toLowerCase();
+    if (baseName.includes("kafka"))
+        return MockProtocol.Kafka;
+    if (baseName.includes("grpc"))
+        return MockProtocol.Grpc;
+    return MockProtocol.Rest;
+}
+function extractBaseUrlFromCommandLine(commandLine) {
+    if (!commandLine)
+        return undefined;
+    const commandMatch = commandLine.match(/skyramp generate mock (?:rest|grpc|kafka)\s+([^\s\\]+)/);
+    if (!commandMatch || commandMatch[1].startsWith("--"))
+        return undefined;
+    return normalizeMockCommandTarget(commandMatch[1]);
+}
+function uniquePythonIdentifier(raw, used) {
+    const base = raw.replace(/\W|^(?=\d)/g, "_");
+    let candidate = base;
+    let suffix = 2;
+    while (used.has(candidate)) {
+        candidate = `${base}_${suffix}`;
+        suffix += 1;
+    }
+    used.add(candidate);
+    return candidate;
+}
+function normalizeMockCommandTarget(target) {
+    if (!target)
+        return undefined;
+    try {
+        const endpointUrl = new URL(target);
+        if (endpointUrl.origin !== "null")
+            return endpointUrl.origin;
+    }
+    catch {
+        // Fall through to host:port handling below.
+    }
+    // gRPC and Kafka mock targets are usually service host:port values without a URL scheme.
+    return /^[A-Za-z0-9_.-]+:\d+$/.test(target) ? target : undefined;
+}
+// Exported for testing
+export { injectMockImports, buildMockImportBlock };

package/build/tools/enrichTestWithMocksTool.test.d.ts

@@ -0,0 +1 @@
+export {};