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

package/build/tools/generate-tests/batchMockGenerationTool.test.js

@@ -0,0 +1,514 @@
+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 mockGenerateRestMock = jest.fn();
+const mockGenerateGrpcMock = jest.fn();
+const mockGenerateKafkaMock = jest.fn();
+jest.unstable_mockModule("@skyramp/skyramp", () => ({
+    SkyrampClient: jest.fn().mockImplementation(() => ({
+        generateRestMock: mockGenerateRestMock,
+        generateGrpcMock: mockGenerateGrpcMock,
+        generateKafkaMock: mockGenerateKafkaMock,
+    })),
+}));
+jest.unstable_mockModule("../../services/AnalyticsService.js", () => ({
+    AnalyticsService: { pushTestGenerationToolEvent: jest.fn() },
+}));
+jest.unstable_mockModule("../../utils/telemetry.js", () => ({
+    getEntryPoint: () => "mcp",
+}));
+const { executeBatchMockGeneration, MockProtocol, BATCH_MOCK_PROTOCOL_EXAMPLES, } = await import("./batchMockGenerationTool.js");
+describe("batchMockGenerationTool", () => {
+    let tempDir;
+    beforeEach(() => {
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "skyramp-batch-mock-"));
+        mockGenerateRestMock.mockReset();
+        mockGenerateGrpcMock.mockReset();
+        mockGenerateKafkaMock.mockReset();
+    });
+    afterEach(() => {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    });
+    it("documents batch protocol-specific required fields with Claude-style example tags", () => {
+        expect(BATCH_MOCK_PROTOCOL_EXAMPLES).toContain('<example protocol="rest">');
+        expect(BATCH_MOCK_PROTOCOL_EXAMPLES).toContain('<example protocol="grpc">');
+        expect(BATCH_MOCK_PROTOCOL_EXAMPLES).toContain('<example protocol="kafka-producer">');
+        expect(BATCH_MOCK_PROTOCOL_EXAMPLES).toContain('<example protocol="kafka-consumer">');
+        expect(BATCH_MOCK_PROTOCOL_EXAMPLES).toContain("endpointURL, method unless apiSchema is provided");
+        expect(BATCH_MOCK_PROTOCOL_EXAMPLES).toContain("protoPath");
+        expect(BATCH_MOCK_PROTOCOL_EXAMPLES).toContain("grpcServiceName");
+        expect(BATCH_MOCK_PROTOCOL_EXAMPLES).toContain("kafkaTopic");
+        expect(BATCH_MOCK_PROTOCOL_EXAMPLES).toContain("Do not pass method");
+        expect(BATCH_MOCK_PROTOCOL_EXAMPLES).toContain("Kafka producer validation item");
+        expect(BATCH_MOCK_PROTOCOL_EXAMPLES).toContain("Kafka consumer message item");
+    });
+    it("requires REST method in batch generation unless apiSchema is provided", async () => {
+        const result = await executeBatchMockGeneration({
+            mocks: [
+                {
+                    protocol: MockProtocol.Rest,
+                    endpointURL: "http://ams:4000/api/v1/validate",
+                    method: "",
+                },
+            ],
+            outputDir: tempDir,
+            language: "python",
+        });
+        expect(result.isError).toBe(true);
+        expect(mockGenerateRestMock).not.toHaveBeenCalled();
+        const text = result.content[0].type === "text" ? result.content[0].text : "";
+        expect(text).toContain("REST mock method is required unless apiSchema is provided for schema-wide generation");
+    });
+    it("allows empty REST method in batch generation when apiSchema is provided", async () => {
+        mockGenerateRestMock.mockResolvedValue("success: rest mock generated");
+        const result = await executeBatchMockGeneration({
+            mocks: [
+                {
+                    protocol: MockProtocol.Rest,
+                    endpointURL: "http://ams:4000",
+                    method: "",
+                    apiSchema: "/repo/openapi.json",
+                },
+            ],
+            outputDir: tempDir,
+            language: "python",
+        });
+        expect(result.isError).toBe(false);
+        expect(mockGenerateRestMock).toHaveBeenCalledTimes(1);
+    });
+    it("blocks loopback REST mocks in Docker local-dev mode", async () => {
+        const result = await executeBatchMockGeneration({
+            mocks: [
+                {
+                    protocol: MockProtocol.Rest,
+                    endpointURL: "http://localhost:4000/api/v1/accounts",
+                    method: "GET",
+                },
+            ],
+            outputDir: tempDir,
+            language: "python",
+            runtime: "docker",
+        });
+        expect(result.isError).toBe(true);
+        expect(mockGenerateRestMock).not.toHaveBeenCalled();
+        const text = result.content[0].type === "text" ? result.content[0].text : "";
+        expect(text).toContain("REST_LOOPBACK_URL");
+    });
+    it("uses Docker local-dev compatibility checks when dockerNetwork is provided", async () => {
+        const result = await executeBatchMockGeneration({
+            mocks: [
+                {
+                    protocol: MockProtocol.Rest,
+                    endpointURL: "http://host.docker.internal:4000/api/v1/accounts",
+                    method: "GET",
+                },
+            ],
+            outputDir: tempDir,
+            language: "python",
+            dockerNetwork: "app_default",
+        });
+        expect(result.isError).toBe(true);
+        expect(mockGenerateRestMock).not.toHaveBeenCalled();
+        const text = result.content[0].type === "text" ? result.content[0].text : "";
+        expect(text).toContain("REST_LOOPBACK_URL");
+    });
+    it("allows loopback REST mocks outside Docker local-dev mode", async () => {
+        mockGenerateRestMock.mockResolvedValue("success: rest mock generated");
+        const result = await executeBatchMockGeneration({
+            mocks: [
+                {
+                    protocol: MockProtocol.Rest,
+                    endpointURL: "http://localhost:4000/api/v1/accounts",
+                    method: "GET",
+                },
+            ],
+            outputDir: tempDir,
+            language: "python",
+        });
+        expect(result.isError).toBe(false);
+        expect(mockGenerateRestMock).toHaveBeenCalledTimes(1);
+    });
+    it("generates multiple REST mocks successfully", async () => {
+        mockGenerateRestMock.mockResolvedValue("success: rest mock generated");
+        const result = await executeBatchMockGeneration({
+            mocks: [
+                {
+                    protocol: MockProtocol.Rest,
+                    endpointURL: "http://accounts-service:4000/api/v1/accounts",
+                    method: "GET",
+                    responseData: JSON.stringify({ id: "acc_123", name: "Test" }),
+                },
+                {
+                    protocol: MockProtocol.Rest,
+                    endpointURL: "http://payments-service:4001/api/v1/payments",
+                    method: "POST",
+                    responseData: JSON.stringify({ payment_id: "pay_456" }),
+                },
+                {
+                    protocol: MockProtocol.Rest,
+                    endpointURL: "http://notifications-service:4002/api/v1/notify",
+                    method: "POST",
+                    responseData: JSON.stringify({ status: "sent" }),
+                },
+            ],
+            outputDir: tempDir,
+            language: "python",
+            runtime: "docker",
+            dockerNetwork: "my-network",
+        });
+        expect(result.isError).toBe(false);
+        expect(mockGenerateRestMock).toHaveBeenCalledTimes(3);
+        const text = result.content[0].type === "text" ? result.content[0].text : "";
+        expect(text).toContain("Succeeded:** 3");
+        expect(text).toContain("Failed:** 0");
+        expect(text).toContain("accounts-service");
+        expect(text).toContain("payments-service");
+        expect(text).toContain("notifications-service");
+    });
+    it("rejects gRPC error-shaped responseData in batch generation", async () => {
+        const result = await executeBatchMockGeneration({
+            mocks: [
+                {
+                    protocol: MockProtocol.Grpc,
+                    endpointURL: "partner-accounts:50051",
+                    method: "GetCustomerConfigurations",
+                    protoPath: "/repo/proto/customer_configurations.proto",
+                    grpcServiceName: "CustomerConfigurationsService",
+                    responseData: JSON.stringify({ error: "DEADLINE_EXCEEDED" }),
+                },
+            ],
+            outputDir: tempDir,
+            language: "python",
+            runtime: "docker",
+        });
+        expect(result.isError).toBe(true);
+        const text = result.content[0].type === "text" ? result.content[0].text : "";
+        expect(text).toContain("gRPC mock responseData cannot simulate gRPC status errors");
+        expect(mockGenerateGrpcMock).not.toHaveBeenCalled();
+    });
+    it("generates mixed REST + gRPC mocks when gRPC runs on the downstream service port", async () => {
+        mockGenerateRestMock.mockResolvedValue("success: rest mock generated");
+        mockGenerateGrpcMock.mockResolvedValue("success: grpc mock generated");
+        const result = await executeBatchMockGeneration({
+            mocks: [
+                {
+                    protocol: MockProtocol.Rest,
+                    endpointURL: "http://accounts-service:4000/api/v1/accounts",
+                    method: "GET",
+                    responseData: JSON.stringify({ id: "acc_123" }),
+                },
+                {
+                    protocol: MockProtocol.Grpc,
+                    endpointURL: "partner-accounts:50051",
+                    method: "GetCustomerConfiguration",
+                    protoPath: "/repo/proto/partner_accounts.proto",
+                    grpcServiceName: "PartnerAccountsService",
+                    responseData: JSON.stringify({ config: { enabled: true } }),
+                },
+            ],
+            outputDir: tempDir,
+            language: "python",
+        });
+        expect(result.isError).toBe(false);
+        expect(mockGenerateRestMock).toHaveBeenCalledTimes(1);
+        expect(mockGenerateGrpcMock).toHaveBeenCalledTimes(1);
+        const text = result.content[0].type === "text" ? result.content[0].text : "";
+        expect(text).toContain("Succeeded:** 2");
+        expect(text).toContain("Failed:** 0");
+    });
+    it("allows gRPC mocks on non-8080 downstream service ports", async () => {
+        mockGenerateRestMock.mockResolvedValue("success: rest mock generated");
+        mockGenerateGrpcMock.mockResolvedValue("success: grpc mock generated");
+        const result = await executeBatchMockGeneration({
+            mocks: [
+                {
+                    protocol: MockProtocol.Rest,
+                    endpointURL: "http://accounts-service:4000/api/v1/accounts",
+                    method: "GET",
+                    responseData: JSON.stringify({ id: "acc_123" }),
+                },
+                {
+                    protocol: MockProtocol.Grpc,
+                    endpointURL: "partner-accounts:9090",
+                    method: "GetCustomerConfiguration",
+                    protoPath: "/repo/proto/partner_accounts.proto",
+                    grpcServiceName: "PartnerAccountsService",
+                    responseData: JSON.stringify({ config: { enabled: true } }),
+                },
+            ],
+            outputDir: tempDir,
+            language: "python",
+        });
+        expect(result.isError).toBe(false);
+        expect(mockGenerateRestMock).toHaveBeenCalledTimes(1);
+        expect(mockGenerateGrpcMock).toHaveBeenCalledTimes(1);
+        const text = result.content[0].type === "text" ? result.content[0].text : "";
+        expect(text).toContain("Succeeded:** 2");
+        expect(text).toContain("Failed:** 0");
+        expect(text).not.toContain("GRPC_PORT_MISMATCH");
+    });
+    it("handles partial failures gracefully", async () => {
+        mockGenerateRestMock.mockResolvedValue("success: rest mock generated");
+        mockGenerateGrpcMock.mockRejectedValue(new Error("Proto file not found"));
+        const result = await executeBatchMockGeneration({
+            mocks: [
+                {
+                    protocol: MockProtocol.Rest,
+                    endpointURL: "http://accounts-service:4000/api/v1/accounts",
+                    method: "GET",
+                    responseData: JSON.stringify({ id: "acc_123" }),
+                },
+                {
+                    protocol: MockProtocol.Grpc,
+                    endpointURL: "partner-accounts:8080",
+                    method: "GetConfig",
+                    protoPath: "/repo/proto/missing.proto",
+                    grpcServiceName: "PartnerAccountsService",
+                    responseData: JSON.stringify({}),
+                },
+            ],
+            outputDir: tempDir,
+            language: "python",
+        });
+        // Not a total failure — some succeeded
+        expect(result.isError).toBe(false);
+        const text = result.content[0].type === "text" ? result.content[0].text : "";
+        expect(text).toContain("Succeeded:** 1");
+        expect(text).toContain("Failed:** 1");
+        expect(text).toContain("Proto file not found");
+    });
+    it("generates Kafka mocks without forwarding a method field", async () => {
+        mockGenerateKafkaMock.mockResolvedValue("success: kafka mock generated");
+        const result = await executeBatchMockGeneration({
+            mocks: [
+                {
+                    protocol: MockProtocol.Kafka,
+                    endpointURL: "redpanda:9092",
+                    kafkaTopic: "events",
+                    requestData: JSON.stringify({ name: "account.created" }),
+                },
+            ],
+            outputDir: tempDir,
+            language: "python",
+            runtime: "docker",
+        });
+        expect(result.isError).toBe(false);
+        expect(mockGenerateKafkaMock).toHaveBeenCalledTimes(1);
+        const kafkaOptions = mockGenerateKafkaMock.mock.calls[0][0];
+        expect(kafkaOptions).toEqual(expect.objectContaining({
+            protocol: MockProtocol.Kafka,
+            url: "redpanda:9092",
+            topic: "events",
+            requestData: JSON.stringify({ name: "account.created" }),
+        }));
+        expect(kafkaOptions).not.toHaveProperty("method");
+    });
+    it("generates Kafka consumer mocks without forwarding empty requestData", async () => {
+        mockGenerateKafkaMock.mockResolvedValue("success: kafka mock generated");
+        const result = await executeBatchMockGeneration({
+            mocks: [
+                {
+                    protocol: MockProtocol.Kafka,
+                    endpointURL: "redpanda:9092",
+                    kafkaTopic: "events",
+                    requestData: "",
+                    responseData: JSON.stringify({ accepted: true }),
+                },
+            ],
+            outputDir: tempDir,
+            language: "python",
+            runtime: "docker",
+        });
+        expect(result.isError).toBe(false);
+        expect(mockGenerateKafkaMock).toHaveBeenCalledTimes(1);
+        const kafkaOptions = mockGenerateKafkaMock.mock.calls[0][0];
+        expect(kafkaOptions).toEqual(expect.objectContaining({
+            protocol: MockProtocol.Kafka,
+            url: "redpanda:9092",
+            topic: "events",
+            responseData: JSON.stringify({ accepted: true }),
+        }));
+        expect(kafkaOptions.requestData).toBeUndefined();
+        expect(kafkaOptions.requestData).not.toBe("");
+        expect(kafkaOptions).not.toHaveProperty("method");
+    });
+    it("rejects Kafka mocks with both requestData and responseData in batch generation", async () => {
+        const result = await executeBatchMockGeneration({
+            mocks: [
+                {
+                    protocol: MockProtocol.Kafka,
+                    endpointURL: "redpanda:9092",
+                    kafkaTopic: "events",
+                    requestData: JSON.stringify({ type: "account.created" }),
+                    responseData: JSON.stringify({ accepted: true }),
+                },
+            ],
+            outputDir: tempDir,
+            language: "python",
+            runtime: "docker",
+        });
+        expect(result.isError).toBe(true);
+        expect(mockGenerateKafkaMock).not.toHaveBeenCalled();
+        const text = result.content[0].type === "text" ? result.content[0].text : "";
+        expect(text).toContain("Kafka mock requires exactly one of requestData");
+    });
+    it("rejects Kafka mocks with neither requestData nor responseData in batch generation", async () => {
+        const result = await executeBatchMockGeneration({
+            mocks: [
+                {
+                    protocol: MockProtocol.Kafka,
+                    endpointURL: "redpanda:9092",
+                    kafkaTopic: "events",
+                },
+            ],
+            outputDir: tempDir,
+            language: "python",
+            runtime: "docker",
+        });
+        expect(result.isError).toBe(true);
+        expect(mockGenerateKafkaMock).not.toHaveBeenCalled();
+        const text = result.content[0].type === "text" ? result.content[0].text : "";
+        expect(text).toContain("Kafka mock requires exactly one of requestData");
+    });
+    it("rejects Kafka method in batch generation", async () => {
+        const result = await executeBatchMockGeneration({
+            mocks: [
+                {
+                    protocol: MockProtocol.Kafka,
+                    endpointURL: "redpanda:9092",
+                    kafkaTopic: "events",
+                    method: "produce",
+                },
+            ],
+            outputDir: tempDir,
+            language: "python",
+            runtime: "docker",
+        });
+        expect(result.isError).toBe(true);
+        const text = result.content[0].type === "text" ? result.content[0].text : "";
+        expect(text).toContain("Kafka mock method must be empty");
+        expect(mockGenerateKafkaMock).not.toHaveBeenCalled();
+    });
+    it("reports validation errors without calling the client", async () => {
+        const result = await executeBatchMockGeneration({
+            mocks: [
+                {
+                    protocol: MockProtocol.Grpc,
+                    endpointURL: "partner-accounts:50051",
+                    method: "GetConfig",
+                    // Missing protoPath and grpcServiceName
+                },
+                {
+                    protocol: MockProtocol.Kafka,
+                    endpointURL: "redpanda:9092",
+                    method: "",
+                    // Missing kafkaTopic
+                },
+            ],
+            outputDir: tempDir,
+            language: "python",
+        });
+        // All failed = isError true
+        expect(result.isError).toBe(true);
+        expect(mockGenerateGrpcMock).not.toHaveBeenCalled();
+        expect(mockGenerateKafkaMock).not.toHaveBeenCalled();
+        const text = result.content[0].type === "text" ? result.content[0].text : "";
+        expect(text).toContain("Failed:** 2");
+        expect(text).toContain("protoPath");
+        expect(text).toContain("grpcServiceName");
+        expect(text).toContain("kafkaTopic");
+    });
+    it("rejects invalid REST HTTP methods without calling the client", async () => {
+        const result = await executeBatchMockGeneration({
+            mocks: [
+                {
+                    protocol: MockProtocol.Rest,
+                    endpointURL: "http://svc:4000/api",
+                    method: "POTS",
+                },
+            ],
+            outputDir: tempDir,
+            language: "python",
+        });
+        expect(result.isError).toBe(true);
+        expect(mockGenerateRestMock).not.toHaveBeenCalled();
+        const text = result.content[0].type === "text" ? result.content[0].text : "";
+        expect(text).toContain('REST mock method must be one of GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS or empty string (got "POTS")');
+    });
+    it("creates output directory if it does not exist", async () => {
+        const nestedDir = path.join(tempDir, "nested", "output", "mocks");
+        mockGenerateRestMock.mockResolvedValue("success: mock created");
+        await executeBatchMockGeneration({
+            mocks: [
+                {
+                    protocol: MockProtocol.Rest,
+                    endpointURL: "http://svc:4000/api",
+                    method: "GET",
+                    responseData: "{}",
+                },
+            ],
+            outputDir: nestedDir,
+            language: "python",
+        });
+        expect(fs.existsSync(nestedDir)).toBe(true);
+    });
+    it("marks result as total failure when all mocks fail", async () => {
+        mockGenerateRestMock.mockRejectedValue(new Error("connection refused"));
+        const result = await executeBatchMockGeneration({
+            mocks: [
+                {
+                    protocol: MockProtocol.Rest,
+                    endpointURL: "http://svc:4000/api",
+                    method: "GET",
+                },
+            ],
+            outputDir: tempDir,
+            language: "python",
+        });
+        expect(result.isError).toBe(true);
+        const text = result.content[0].type === "text" ? result.content[0].text : "";
+        expect(text).toContain("Failed:** 1");
+        expect(text).toContain("connection refused");
+    });
+    it("normalizes padded lowercase REST HTTP methods before backend generation", async () => {
+        mockGenerateRestMock.mockResolvedValue("success: rest mock generated");
+        await executeBatchMockGeneration({
+            mocks: [
+                {
+                    protocol: MockProtocol.Rest,
+                    endpointURL: "http://svc:4000/api",
+                    method: " post\n",
+                },
+            ],
+            outputDir: tempDir,
+            language: "python",
+        });
+        expect(mockGenerateRestMock).toHaveBeenCalledWith(expect.objectContaining({ method: "POST" }));
+    });
+    it("passes shared params to all generated options", async () => {
+        mockGenerateRestMock.mockResolvedValue("success: mock created");
+        await executeBatchMockGeneration({
+            mocks: [
+                {
+                    protocol: MockProtocol.Rest,
+                    endpointURL: "http://svc:4000/api",
+                    method: "GET",
+                },
+            ],
+            outputDir: tempDir,
+            runtime: "docker",
+            dockerNetwork: "test-net",
+            language: "typescript",
+            framework: "playwright",
+        });
+        expect(mockGenerateRestMock).toHaveBeenCalledWith(expect.objectContaining({
+            outputDir: tempDir,
+            runtime: "docker",
+            dockerNetwork: "test-net",
+            language: "typescript",
+            framework: "playwright",
+        }));
+    });
+});

package/build/tools/generate-tests/generateContractRestTool.js

@@ -357,8 +357,8 @@ const TOOL_NAME = "skyramp_contract_test_generation";
 const MODES_SECTION = CONSUMER_MODE_ENABLED
     ? `**Modes:**
 - Default (no mode set): both \`providerMode\` and \`consumerMode\` default to false. This generates both provider and consumer contract tests — equivalent to setting both modes to true.
-- \`providerMode\`: set to true ONLY if the user explicitly requests a provider-side contract test. Optionally specify \`providerOutput\` for the output file path.
-- \`consumerMode\`: set to true ONLY if the user explicitly requests a consumer-side contract test. Optionally specify \`consumerOutput\` for the output file path.
+- \`providerMode\`: set to true ONLY if the user explicitly requests a provider-side contract test. Optionally specify \`providerOutput\` for the output file path. Provider tests hit the real endpoint — no mocks.
+- \`consumerMode\`: set to true ONLY if the user explicitly requests a consumer-side contract test. Optionally specify \`consumerOutput\` for the output file path. Consumer tests include mocks wired inline (\`client.apply_mock(mock)\` in the test function) — no separate \`skyramp_enrich_test_with_mocks\` call needed.
 - Both \`providerMode\` and \`consumerMode\` can be enabled simultaneously to generate both sides.`
     : `**Mode:**
 - Only provider-side contract tests are generated. Pass \`providerMode: true\` (or omit it — the tool always behaves as provider-only). Optionally specify \`providerOutput\` for the output file path.`;

package/build/tools/generate-tests/generateMockRestTool.d.ts

@@ -1,9 +1,17 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { TestType } from "../../types/TestTypes.js";
+import { MockProtocol } from "../../types/TestTypes.js";
+export { MockProtocol } from "../../types/TestTypes.js";
 import { TestGenerationService } from "../../services/TestGenerationService.js";
 import { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
+export declare const MOCK_PROTOCOL_EXAMPLES = "\n<example protocol=\"rest\">\nGenerate a REST mock for one HTTP endpoint. Required fields: protocol=\"rest\", endpointURL, method. Use apiSchema with an empty method only when intentionally generating all schema methods.\n{\n  \"protocol\": \"rest\",\n  \"endpointURL\": \"http://payment-service:5001/orders/:order_id/payment_authorizations\",\n  \"method\": \"PUT\",\n  \"requestAware\": true,\n  \"requestData\": \"{\"payment_method_id\":\"pm_123\"}\",\n  \"responseData\": \"{\"accepted\":true}\",\n  \"responseStatusCode\": \"200\"\n}\n</example>\n\n<example protocol=\"grpc\">\nGenerate a gRPC mock. Required fields: protocol=\"grpc\", endpointURL as host:port, protoPath, grpcServiceName. method is the RPC method name; omit or leave empty to generate all service methods. responseData must be a successful protobuf-shaped response, not a gRPC status error.\n{\n  \"protocol\": \"grpc\",\n  \"endpointURL\": \"profile-service:50051\",\n  \"protoPath\": \"/repo/proto/profiles.proto\",\n  \"grpcServiceName\": \"ProfileService\",\n  \"method\": \"GetProfile\",\n  \"responseData\": \"{\"eligible\":true}\"\n}\n</example>\n\n<example protocol=\"kafka-producer\">\nGenerate a Kafka producer validation mock. Required fields: protocol=\"kafka\", endpointURL as broker host:port, kafkaTopic, and requestData. Do not pass method or responseData.\n{\n  \"protocol\": \"kafka\",\n  \"endpointURL\": \"broker:9092\",\n  \"kafkaTopic\": \"events\",\n  \"requestData\": \"{\"name\":\"order.created\"}\"\n}\n</example>\n\n<example protocol=\"kafka-consumer\">\nGenerate a Kafka consumer message mock. Required fields: protocol=\"kafka\", endpointURL as broker host:port, kafkaTopic, and responseData. Do not pass method or requestData.\n{\n  \"protocol\": \"kafka\",\n  \"endpointURL\": \"broker:9092\",\n  \"kafkaTopic\": \"events\",\n  \"responseData\": \"{\"accepted\":true}\"\n}\n</example>";
 type MockParams = {
+    protocol?: MockProtocol;
     endpointURL?: string;
+    protoPath?: string;
+    grpcServiceName?: string;
+    protobufExtraFiles?: string[];
+    protobufExtraImportPath?: string[];
+    kafkaTopic?: string;
     method?: string;
     apiSchema?: string;
     responseData?: string;
@@ -29,13 +37,18 @@ type MockParams = {
     prompt?: string;
 };
 export declare class MockGenerationService extends TestGenerationService {
-    protected getTestType(): TestType;
+    protected getTestType(): "mock";
     generateTest(params: MockParams & Record<string, any>): Promise<CallToolResult>;
     private buildReorganizationInstructions;
+    protected validateInputs(params: MockParams & Record<string, any>): CallToolResult;
     protected buildGenerationOptions(params: MockParams): {
-        uri: string | undefined;
         method: string | undefined;
-        apiSchema: string[];
+        url: string | undefined;
+        protoPath: string | undefined;
+        service: string | undefined;
+        extraFiles: string[];
+        extraImports: string[];
+        protocol: MockProtocol;
         language: string;
         framework: string;
         output: string | undefined;
@@ -48,17 +61,54 @@ export declare class MockGenerationService extends TestGenerationService {
         k8sNamespace: string | undefined;
         k8sConfig: string | undefined;
         k8sContext: string | undefined;
+        responseData: string | undefined;
+        entrypoint: string;
+    } | {
+        url: string | undefined;
+        topic: string | undefined;
         requestData: string | undefined;
+        protocol: MockProtocol;
+        language: string;
+        framework: string;
+        output: string | undefined;
+        outputDir: string;
+        force: boolean;
+        deployDashboard: boolean | undefined;
+        runtime: string | undefined;
+        dockerNetwork: string | undefined;
+        dockerWorkerPort: string;
+        k8sNamespace: string | undefined;
+        k8sConfig: string | undefined;
+        k8sContext: string | undefined;
         responseData: string | undefined;
+        entrypoint: string;
+    } | {
+        method: string;
+        uri: string | undefined;
+        apiSchema: string[];
+        requestData: string | undefined;
         responseStatusCode: string | undefined;
         formParams: string | undefined;
         requestAware: boolean | undefined;
         traceFilePath: string | undefined;
-        entrypoint: string;
         mockPort: number;
         optionalFields: boolean;
+        protocol: MockProtocol;
+        language: string;
+        framework: string;
+        output: string | undefined;
+        outputDir: string;
+        force: boolean;
+        deployDashboard: boolean | undefined;
+        runtime: string | undefined;
+        dockerNetwork: string | undefined;
+        dockerWorkerPort: string;
+        k8sNamespace: string | undefined;
+        k8sConfig: string | undefined;
+        k8sContext: string | undefined;
+        responseData: string | undefined;
+        entrypoint: string;
     };
     protected executeGeneration(generateOptions: any): Promise<string>;
 }
 export declare function registerMockTool(server: McpServer): void;
-export {};