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

package/build/tools/generateEnrichedIntegrationTestTool.js

@@ -0,0 +1,209 @@
+import { z } from "zod";
+import { SkyrampClient } from "@skyramp/skyramp";
+import { logger } from "../utils/logger.js";
+import { injectMockImports } from "./enrichTestWithMocksTool.js";
+import { isAuthorizationHeaderName } from "../utils/workspaceAuth.js";
+import * as fs from "fs";
+import * as path from "path";
+const TOOL_NAME = "skyramp_generate_enriched_integration_test";
+const enrichedIntegrationTestSchema = {
+    scenarioFile: z
+        .string()
+        .describe("Absolute path to the scenario JSON file (from skyramp_batch_scenario_test_generation). Used as trace input for integration test generation."),
+    mockFiles: z
+        .array(z.string())
+        .describe("Absolute paths to the generated mock files (from skyramp_mock_generation or skyramp_batch_mock_generation) that this test needs."),
+    scenarioName: z
+        .string()
+        .describe("Human-readable scenario name (e.g., order-happy-path). Used as the SCENARIO_NAME constant in the enriched test."),
+    outputDir: z
+        .string()
+        .describe("Absolute path to the directory where the test file will be written."),
+    output: z
+        .string()
+        .optional()
+        .describe("Output test file name (e.g., order_happy_path_integration_test.py). Derived from scenario if omitted."),
+    runtime: z
+        .string()
+        .optional()
+        .default("docker")
+        .describe("Runtime environment: 'docker' or 'k8s'. Defaults to docker."),
+    dockerNetwork: z
+        .string()
+        .optional()
+        .describe("Docker network name for the test runtime."),
+    authHeader: z
+        .string()
+        .optional()
+        .describe("HTTP header that carries the auth credential (e.g., Authorization, X-Api-Key)."),
+    authScheme: z
+        .string()
+        .optional()
+        .describe("Auth scheme prefix (e.g., Bearer). Mapped to authType for the backend."),
+    language: z
+        .string()
+        .optional()
+        .describe("Programming language for the generated test (e.g., python, typescript)."),
+    framework: z
+        .string()
+        .optional()
+        .describe("Test framework (e.g., pytest, playwright)."),
+    traceComments: z
+        .array(z.string())
+        .optional()
+        .describe("Optional trace comments showing how mock values flow to assertions."),
+};
+/**
+ * skyramp_generate_enriched_integration_test
+ *
+ * Combines integration test generation (from a scenario file) and mock enrichment
+ * into a single atomic operation. Eliminates the need to call
+ * skyramp_integration_test_generation and skyramp_enrich_test_with_mocks separately.
+ */
+export function registerGenerateEnrichedIntegrationTestTool(server) {
+    server.registerTool(TOOL_NAME, {
+        description: "Generate an integration test from a scenario file AND enrich it with mock imports in one step. " +
+            "Combines skyramp_integration_test_generation + skyramp_enrich_test_with_mocks into a single call. " +
+            "Use this after skyramp_batch_scenario_test_generation and skyramp_batch_mock_generation to " +
+            "produce a fully wired test file ready for execution.",
+        inputSchema: enrichedIntegrationTestSchema,
+    }, async (params) => {
+        return executeGenerateEnrichedIntegrationTest(params);
+    });
+}
+export async function executeGenerateEnrichedIntegrationTest(params) {
+    const { scenarioFile, mockFiles, scenarioName, outputDir, output, runtime, dockerNetwork, authHeader, authScheme, language, framework, traceComments, } = params;
+    try {
+        // Step 1: Validate language — enrichment currently supports Python only
+        if (language && language !== "python") {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `**Error:** Mock enrichment is currently supported only for Python tests; received language "${language}". Use \`skyramp_integration_test_generation\` followed by \`skyramp_enrich_test_with_mocks\` for non-Python languages.`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        // Step 1b: Validate scenarioFile exists
+        if (!fs.existsSync(scenarioFile)) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `**Error:** Scenario file not found: ${scenarioFile}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        // Step 1b: 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_batch_mock_generation\`.`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        // Step 2: Generate the integration test
+        // Normalize auth params: the Go CLI treats --auth-type and --auth-header as
+        // mutually exclusive when authHeader is the standard Authorization header.
+        // Mirror TestGenerationService.executeGeneration() normalization:
+        // if authScheme is set and authHeader is Authorization, use authType only.
+        let resolvedAuthHeader = authHeader;
+        const resolvedAuthType = authScheme;
+        if (resolvedAuthType !== undefined && isAuthorizationHeaderName(resolvedAuthHeader || "")) {
+            resolvedAuthHeader = undefined;
+        }
+        const client = new SkyrampClient();
+        const result = await client.generateRestTest({
+            traceFilePath: scenarioFile,
+            outputDir,
+            output,
+            runtime,
+            force: true,
+            dockerNetwork,
+            authHeader: resolvedAuthHeader,
+            authType: resolvedAuthType,
+            language,
+            framework,
+            testType: "integration",
+        });
+        // Check if generation succeeded
+        if (!result || !result.toLowerCase().includes("success")) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `**Error:** Integration test generation failed: ${result || "no output from backend"}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        // Step 3: Determine the test file path and read it
+        const testFileName = output || deriveTestFileName(scenarioFile, language);
+        const testFilePath = path.join(outputDir, testFileName);
+        if (!fs.existsSync(testFilePath)) {
+            return {
+                content: [
+                    {
+                        type: "text",
+                        text: `**Error:** Generated test file not found at expected path: ${testFilePath}\n` +
+                            `Backend output: ${result}`,
+                    },
+                ],
+                isError: true,
+            };
+        }
+        const testContent = fs.readFileSync(testFilePath, "utf-8");
+        // Step 4: Enrich with mock imports
+        const enrichedContent = injectMockImports(testContent, testFilePath, scenarioName, mockFiles, traceComments);
+        // Step 5: Write the enriched content back
+        fs.writeFileSync(testFilePath, enrichedContent);
+        logger.info(`Generated and enriched integration test: ${testFilePath}`, {
+            scenarioName,
+            mockFileCount: mockFiles.length,
+        });
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: [
+                        `**Integration test generated and enriched with mocks for scenario "${scenarioName}".**\n`,
+                        `**Test file:** ${testFilePath}`,
+                        `**Mock files imported:** ${mockFiles.length}`,
+                        ...mockFiles.map((f) => `  - ${path.basename(f)}`),
+                        `\nThe test is ready for execution with: \`skyramp_execute_test({testFile: "${testFilePath}", ...})\``,
+                    ].join("\n"),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        logger.error(`Failed to generate enriched integration test: ${error.message}`);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: `**Failed to generate enriched integration test:** ${error.message}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}
+function deriveTestFileName(scenarioFile, language) {
+    const base = path.basename(scenarioFile, ".json");
+    const name = base.replace(/^scenario_/, "").replace(/[^a-zA-Z0-9]/g, "_");
+    const ext = language === "typescript" || language === "javascript" ? ".spec.ts" : ".py";
+    return `${name}_integration_test${ext}`;
+}

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

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

package/build/tools/generateEnrichedIntegrationTestTool.test.js

@@ -0,0 +1,199 @@
+import { jest, describe, it, expect, beforeEach, afterEach } from "@jest/globals";
+import * as fs from "fs";
+import * as os from "os";
+import * as path from "path";
+// Mock the SkyrampClient
+const mockGenerateRestTest = jest.fn();
+jest.unstable_mockModule("@skyramp/skyramp", () => ({
+    SkyrampClient: jest.fn().mockImplementation(() => ({
+        generateRestTest: mockGenerateRestTest,
+    })),
+}));
+jest.unstable_mockModule("../utils/logger.js", () => ({
+    logger: {
+        info: jest.fn(),
+        error: jest.fn(),
+        warning: jest.fn(),
+    },
+}));
+const { executeGenerateEnrichedIntegrationTest } = await import("./generateEnrichedIntegrationTestTool.js");
+describe("generateEnrichedIntegrationTestTool", () => {
+    let tempDir;
+    let scenarioFile;
+    let mockFile1;
+    let mockFile2;
+    let mocksDir;
+    beforeEach(() => {
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "skyramp-enriched-test-"));
+        mocksDir = path.join(tempDir, "mocks");
+        fs.mkdirSync(mocksDir, { recursive: true });
+        // Create a scenario file
+        scenarioFile = path.join(tempDir, "scenario_partner-happy-path.json");
+        fs.writeFileSync(scenarioFile, JSON.stringify({ steps: [] }));
+        // Create mock files
+        mockFile1 = path.join(mocksDir, "accounts_GET_mock.py");
+        fs.writeFileSync(mockFile1, '# Command: skyramp generate mock rest http://accounts-service:4000/api/v1/accounts\ndef get_all_mocks():\n    return []\n');
+        mockFile2 = path.join(mocksDir, "payments_POST_mock.py");
+        fs.writeFileSync(mockFile2, '# Command: skyramp generate mock rest http://payments-service:4001/api/v1/payments\ndef get_all_mocks():\n    return []\n');
+        mockGenerateRestTest.mockReset();
+    });
+    afterEach(() => {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    });
+    it("generates and enriches successfully", async () => {
+        // The backend writes the test file on success
+        const testFileName = "partner_happy_path_integration_test.py";
+        const testFilePath = path.join(tempDir, testFileName);
+        mockGenerateRestTest.mockImplementation(async () => {
+            // Simulate backend writing the test file
+            fs.writeFileSync(testFilePath, [
+                "import skyramp",
+                "",
+                "def test_integration():",
+                "    client = skyramp.Client(",
+                '        "docker"',
+                "    )",
+                "    response = client.send_request()",
+                "    assert response.status_code == 200",
+                "",
+            ].join("\n"));
+            return "success: integration test generated";
+        });
+        const result = await executeGenerateEnrichedIntegrationTest({
+            scenarioFile,
+            mockFiles: [mockFile1, mockFile2],
+            scenarioName: "partner-happy-path",
+            outputDir: tempDir,
+            output: testFileName,
+            runtime: "docker",
+            dockerNetwork: "test-network",
+            language: "python",
+            framework: "pytest",
+        });
+        expect(result.isError).toBeUndefined();
+        const text = result.content[0].type === "text" ? result.content[0].text : "";
+        expect(text).toContain("partner-happy-path");
+        expect(text).toContain(testFilePath);
+        expect(text).toContain("Mock files imported:** 2");
+        // Verify the file was enriched with mock imports
+        const written = fs.readFileSync(testFilePath, "utf-8");
+        expect(written).toContain("MOCK_SERVICES = {");
+        expect(written).toContain("apply_all_mocks(client)");
+        // Verify the client was called with correct options
+        expect(mockGenerateRestTest).toHaveBeenCalledWith(expect.objectContaining({
+            traceFilePath: scenarioFile,
+            outputDir: tempDir,
+            output: testFileName,
+            runtime: "docker",
+            force: true,
+            dockerNetwork: "test-network",
+            language: "python",
+            framework: "pytest",
+            testType: "integration",
+        }));
+    });
+    it("returns error when scenario file missing", async () => {
+        const result = await executeGenerateEnrichedIntegrationTest({
+            scenarioFile: "/nonexistent/scenario.json",
+            mockFiles: [mockFile1],
+            scenarioName: "test",
+            outputDir: tempDir,
+        });
+        expect(result.isError).toBe(true);
+        const text = result.content[0].type === "text" ? result.content[0].text : "";
+        expect(text).toContain("Scenario file not found");
+        expect(text).toContain("/nonexistent/scenario.json");
+        expect(mockGenerateRestTest).not.toHaveBeenCalled();
+    });
+    it("returns error when mock files missing", async () => {
+        const result = await executeGenerateEnrichedIntegrationTest({
+            scenarioFile,
+            mockFiles: [mockFile1, "/nonexistent/mock.py"],
+            scenarioName: "test",
+            outputDir: tempDir,
+        });
+        expect(result.isError).toBe(true);
+        const text = result.content[0].type === "text" ? result.content[0].text : "";
+        expect(text).toContain("Mock files not found");
+        expect(text).toContain("/nonexistent/mock.py");
+        expect(mockGenerateRestTest).not.toHaveBeenCalled();
+    });
+    it("returns error when backend generation fails", async () => {
+        mockGenerateRestTest.mockRejectedValue(new Error("Backend connection refused"));
+        const result = await executeGenerateEnrichedIntegrationTest({
+            scenarioFile,
+            mockFiles: [mockFile1],
+            scenarioName: "test",
+            outputDir: tempDir,
+            output: "test_integration_test.py",
+        });
+        expect(result.isError).toBe(true);
+        const text = result.content[0].type === "text" ? result.content[0].text : "";
+        expect(text).toContain("Backend connection refused");
+    });
+    it("returns error when generation result does not indicate success", async () => {
+        mockGenerateRestTest.mockResolvedValue("error: failed to parse scenario");
+        const result = await executeGenerateEnrichedIntegrationTest({
+            scenarioFile,
+            mockFiles: [mockFile1],
+            scenarioName: "test",
+            outputDir: tempDir,
+            output: "test_integration_test.py",
+        });
+        expect(result.isError).toBe(true);
+        const text = result.content[0].type === "text" ? result.content[0].text : "";
+        expect(text).toContain("Integration test generation failed");
+    });
+    it("maps authScheme to authType and drops Authorization header to avoid CLI conflict", async () => {
+        // The Go CLI treats --auth-type and --auth-header as mutually exclusive.
+        // When authScheme is set and authHeader is the standard Authorization header,
+        // authHeader must be omitted so the backend doesn't return
+        // "Auth header and auth type cannot be supported at the same time".
+        const testFileName = "auth_test_integration_test.py";
+        const testFilePath = path.join(tempDir, testFileName);
+        mockGenerateRestTest.mockImplementation(async () => {
+            fs.writeFileSync(testFilePath, [
+                "import skyramp",
+                "",
+                "def test_integration():",
+                "    client = skyramp.Client(",
+                '        "docker"',
+                "    )",
+                "    response = client.send_request()",
+                "",
+            ].join("\n"));
+            return "success: test generated";
+        });
+        await executeGenerateEnrichedIntegrationTest({
+            scenarioFile,
+            mockFiles: [mockFile1],
+            scenarioName: "auth-test",
+            outputDir: tempDir,
+            output: testFileName,
+            authScheme: "Bearer",
+            authHeader: "Authorization",
+        });
+        // authType: "Bearer" present, authHeader must NOT be present (mutually exclusive)
+        expect(mockGenerateRestTest).toHaveBeenCalledWith(expect.objectContaining({ authType: "Bearer" }));
+        expect(mockGenerateRestTest).not.toHaveBeenCalledWith(expect.objectContaining({ authHeader: "Authorization" }));
+    });
+    it("preserves non-Authorization authHeader alongside authType", async () => {
+        // Non-standard auth headers (X-Api-Key, etc.) are not mutually exclusive with authType.
+        const testFileName = "apikey_test_integration_test.py";
+        const testFilePath = path.join(tempDir, testFileName);
+        mockGenerateRestTest.mockImplementation(async () => {
+            fs.writeFileSync(testFilePath, "import skyramp\ndef test_integration(): pass\n");
+            return "success: test generated";
+        });
+        await executeGenerateEnrichedIntegrationTest({
+            scenarioFile,
+            mockFiles: [mockFile1],
+            scenarioName: "apikey-test",
+            outputDir: tempDir,
+            output: testFileName,
+            authScheme: "ApiKey",
+            authHeader: "X-Api-Key",
+        });
+        expect(mockGenerateRestTest).toHaveBeenCalledWith(expect.objectContaining({ authType: "ApiKey", authHeader: "X-Api-Key" }));
+    });
+});

package/build/tools/one-click/oneClickTool.d.ts

@@ -1,4 +1,8 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare enum CallingAgentIde {
+    Cursor = "cursor",
+    Claude = "claude"
+}
 /** User params passed to workflow builder (optional fields may be undefined) */
 export type OneClickParams = {
     workflow: string;
@@ -7,5 +11,11 @@ export type OneClickParams = {
     apiSchema?: string;
     topN?: number;
     token?: string;
+    baseBranch?: string;
+    servicesToMock?: string;
+    realServices?: string;
+    mockProtocols?: string;
+    callingAgent?: CallingAgentIde;
+    rawCallingAgent?: string;
 };
 export declare function registerOneClickTool(server: McpServer): void;