test: add formatBuildSuccessResponse, detectTemplateMismatch, scenario and generator tests

Author: rahmanunver

packages/pluggable-widgets-mcp/src/__test-utils__/mcp-test-harness.ts

@@ -3,6 +3,27 @@ import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import type { SessionState } from "@/tools/session-state";
 
+// ─── Protocol Recording Types ────────────────────────────────────────────────
+
+export interface ProtocolRecord {
+    timestamp: number;
+    direction: "client-to-server" | "server-to-client";
+    message: unknown;
+}
+
+export interface ToolCallRecord {
+    name: string;
+    arguments: unknown;
+    timestamp: number;
+}
+
+export interface RecordingMcpTestContext extends McpTestContext {
+    records: ProtocolRecord[];
+    getToolCalls(): ToolCallRecord[];
+    getToolCallSequence(): string[];
+    assertToolOrder(expectedNames: string[]): void;
+}
+
 type ToolRegistrationFn = (server: McpServer, state: SessionState) => void;
 
 interface McpTestContext {
@@ -30,6 +51,8 @@ export function isError(result: Awaited<ReturnType<Client["callTool"]>>): boolea
     return "isError" in result && result.isError === true;
 }
 
+// ─── Core Test Context ────────────────────────────────────────────────────────
+
 export async function createMcpTestContext(...registerFns: ToolRegistrationFn[]): Promise<McpTestContext> {
     const state: SessionState = { projectDir: undefined };
 
@@ -65,3 +88,99 @@ export async function createMcpTestContext(...registerFns: ToolRegistrationFn[])
         }
     };
 }
+
+// ─── Recording Test Context ───────────────────────────────────────────────────
+
+/**
+ * Creates an MCP test context that records all JSON-RPC messages in both directions.
+ * Wraps InMemoryTransport.send and onmessage post-connection to intercept traffic.
+ */
+export async function createRecordingMcpTestContext(
+    ...registerFns: ToolRegistrationFn[]
+): Promise<RecordingMcpTestContext> {
+    const records: ProtocolRecord[] = [];
+    const state: SessionState = { projectDir: undefined };
+
+    const server = new McpServer(
+        { name: "test-server", version: "0.0.0" },
+        { capabilities: { tools: {}, logging: {} } }
+    );
+
+    if (registerFns.length === 0) {
+        const { registerProjectTools } = await import("@/tools/project.tools");
+        registerProjectTools(server, state);
+    } else {
+        for (const fn of registerFns) {
+            fn(server, state);
+        }
+    }
+
+    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+    const client = new Client({ name: "test-client", version: "0.0.0" });
+
+    await server.connect(serverTransport);
+    await client.connect(clientTransport);
+
+    // Intercept outgoing client messages (client → server)
+    const originalClientSend = clientTransport.send.bind(clientTransport);
+    clientTransport.send = async (message: unknown, options?: unknown) => {
+        records.push({ timestamp: Date.now(), direction: "client-to-server", message });
+        return (originalClientSend as (m: unknown, o?: unknown) => Promise<void>)(message, options);
+    };
+
+    // Intercept incoming client messages (server → client)
+    const originalOnMessage = clientTransport.onmessage;
+    clientTransport.onmessage = (message: unknown, extra?: unknown) => {
+        records.push({ timestamp: Date.now(), direction: "server-to-client", message });
+        (originalOnMessage as ((m: unknown, e?: unknown) => void) | undefined)?.(message, extra);
+    };
+
+    const getToolCalls = (): ToolCallRecord[] =>
+        records
+            .filter(r => {
+                const msg = r.message as Record<string, unknown>;
+                return r.direction === "client-to-server" && msg.method === "tools/call";
+            })
+            .map(r => {
+                const msg = r.message as Record<string, unknown>;
+                const params = msg.params as Record<string, unknown>;
+                return {
+                    name: params.name as string,
+                    arguments: params.arguments,
+                    timestamp: r.timestamp
+                };
+            });
+
+    const getToolCallSequence = (): string[] => getToolCalls().map(c => c.name);
+
+    const assertToolOrder = (expectedNames: string[]): void => {
+        const actual = getToolCallSequence();
+        if (actual.length < expectedNames.length) {
+            throw new Error(
+                `Expected tool call sequence ${JSON.stringify(expectedNames)} but only got ${JSON.stringify(actual)}`
+            );
+        }
+        for (let i = 0; i < expectedNames.length; i++) {
+            if (actual[i] !== expectedNames[i]) {
+                throw new Error(
+                    `Tool call at index ${i}: expected "${expectedNames[i]}" but got "${actual[i]}"\n` +
+                        `Full sequence: ${JSON.stringify(actual)}`
+                );
+            }
+        }
+    };
+
+    return {
+        server,
+        client,
+        state,
+        records,
+        getToolCalls,
+        getToolCallSequence,
+        assertToolOrder,
+        cleanup: async () => {
+            await client.close();
+            await server.close();
+        }
+    };
+}

packages/pluggable-widgets-mcp/src/__tests__/scenarios/widget-lifecycle.test.ts

@@ -0,0 +1,250 @@
+/**
+ * Integration scenario tests that simulate complete Maia workflows.
+ * Uses the recording harness to verify tool ordering and state transitions.
+ * The generator is mocked so tests run fast without Yeoman scaffolding.
+ */
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import {
+    createMcpTestContext,
+    createRecordingMcpTestContext,
+    getResultText,
+    isError
+} from "@/__test-utils__/mcp-test-harness";
+import { createTempMendixProject } from "@/__test-utils__/temp-dir";
+import type { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import type { SessionState } from "@/tools/session-state";
+
+vi.mock("@/tools/utils/generator", () => ({
+    buildWidgetOptions: (args: Record<string, unknown>) => ({
+        name: args.name ?? "ScenarioWidget",
+        description: args.description ?? "scenario test",
+        version: "1.0.0",
+        author: "Mendix",
+        license: "Apache-2.0",
+        organization: "Mendix",
+        template: "empty",
+        programmingLanguage: "typescript",
+        unitTests: false,
+        e2eTests: false
+    }),
+    runWidgetGenerator: vi.fn().mockResolvedValue(undefined),
+    SCAFFOLD_PROGRESS: {
+        START: { progress: 0, message: "Starting..." },
+        COMPLETE: { progress: 100, message: "Done!" }
+    }
+}));
+
+describe("discovery workflow", () => {
+    let client: Client;
+    let state: SessionState;
+    let cleanup: () => Promise<void>;
+    const tempCleanups: Array<() => void> = [];
+
+    beforeEach(async () => {
+        ({ client, state, cleanup } = await createMcpTestContext());
+    });
+
+    afterEach(async () => {
+        await cleanup();
+        for (const c of tempCleanups) c();
+        tempCleanups.length = 0;
+    });
+
+    it("get-project-info (no project) → set-project-directory → get-project-info (success)", async () => {
+        // Step 1: get-project-info with no project configured
+        const noProjectResult = await client.callTool({ name: "get-project-info", arguments: {} });
+        expect(isError(noProjectResult)).toBe(true);
+        expect(getResultText(noProjectResult)).toContain("ERR_PROJECT_NOT_CONFIGURED");
+
+        // Step 2: set-project-directory with a valid project
+        const { dir, cleanup: tempCleanup } = createTempMendixProject({ projectName: "DiscoveryApp" });
+        tempCleanups.push(tempCleanup);
+
+        const setResult = await client.callTool({
+            name: "set-project-directory",
+            arguments: { projectDir: dir }
+        });
+        expect(isError(setResult)).toBe(false);
+        expect(state.projectDir).toBe(dir);
+
+        // Step 3: get-project-info now succeeds with project name
+        const infoResult = await client.callTool({ name: "get-project-info", arguments: {} });
+        expect(isError(infoResult)).toBe(false);
+        expect(getResultText(infoResult)).toContain("DiscoveryApp");
+    });
+});
+
+describe("scaffold workflow", () => {
+    let client: Client;
+    let state: SessionState;
+    let cleanup: () => Promise<void>;
+    const tempCleanups: Array<() => void> = [];
+
+    beforeEach(async () => {
+        const { registerScaffoldingTools } = await import("@/tools/scaffolding.tools");
+        const { registerFileOperationTools } = await import("@/tools/file-operations.tools");
+        ({ client, state, cleanup } = await createMcpTestContext(registerScaffoldingTools, registerFileOperationTools));
+    });
+
+    afterEach(async () => {
+        await cleanup();
+        for (const c of tempCleanups) c();
+        tempCleanups.length = 0;
+    });
+
+    it("set-project-directory → create-widget returns valid path", async () => {
+        const { dir, cleanup: tempCleanup } = createTempMendixProject();
+        tempCleanups.push(tempCleanup);
+        state.projectDir = dir;
+
+        // create-widget with outputPath inside projectDir (passes sandbox check)
+        const outputPath = dir + "/widgets-out";
+        const createResult = await client.callTool({
+            name: "create-widget",
+            arguments: {
+                name: "ScenarioWidget",
+                description: "scenario test",
+                outputPath
+            }
+        });
+        expect(isError(createResult)).toBe(false);
+        const text = getResultText(createResult);
+        expect(text).toContain("ScenarioWidget");
+        expect(text).toContain("created successfully");
+    });
+});
+
+describe("error recovery", () => {
+    let client: Client;
+    let state: SessionState;
+    let cleanup: () => Promise<void>;
+    const tempCleanups: Array<() => void> = [];
+
+    beforeEach(async () => {
+        ({ client, state, cleanup } = await createMcpTestContext());
+    });
+
+    afterEach(async () => {
+        await cleanup();
+        for (const c of tempCleanups) c();
+        tempCleanups.length = 0;
+    });
+
+    it("get-project-info on invalid path → returns structured error with suggestion", async () => {
+        state.projectDir = "/nonexistent/path/to/project";
+
+        const result = await client.callTool({ name: "get-project-info", arguments: {} });
+        expect(isError(result)).toBe(true);
+        const text = getResultText(result);
+
+        // Error is structured and actionable
+        expect(text).toContain("ERR_PROJECT_NOT_CONFIGURED");
+        expect(text).toContain("Suggestion");
+    });
+
+    it("set-project-directory with invalid path → state unchanged, actionable error returned", async () => {
+        state.projectDir = undefined;
+
+        const result = await client.callTool({
+            name: "set-project-directory",
+            arguments: { projectDir: "/completely/nonexistent" }
+        });
+        expect(isError(result)).toBe(true);
+        expect(state.projectDir).toBeUndefined();
+        const text = getResultText(result);
+        expect(text).toContain("ERR_PROJECT_NOT_CONFIGURED");
+
+        // Retry with valid path
+        const { dir, cleanup: tempCleanup } = createTempMendixProject();
+        tempCleanups.push(tempCleanup);
+
+        const retryResult = await client.callTool({
+            name: "set-project-directory",
+            arguments: { projectDir: dir }
+        });
+        expect(isError(retryResult)).toBe(false);
+        expect(state.projectDir).toBe(dir);
+    });
+});
+
+describe("protocol recording captures tool sequence", () => {
+    let cleanup: () => Promise<void>;
+    const tempCleanups: Array<() => void> = [];
+
+    afterEach(async () => {
+        await cleanup();
+        for (const c of tempCleanups) c();
+        tempCleanups.length = 0;
+    });
+
+    it("records tool calls in order and assertToolOrder passes", async () => {
+        const ctx = await createRecordingMcpTestContext();
+        cleanup = ctx.cleanup;
+
+        const { dir, cleanup: tempCleanup } = createTempMendixProject({ projectName: "RecordingApp" });
+        tempCleanups.push(tempCleanup);
+
+        // Call two tools in sequence
+        await ctx.client.callTool({ name: "get-project-info", arguments: {} });
+        ctx.state.projectDir = dir;
+        await ctx.client.callTool({ name: "get-project-info", arguments: {} });
+
+        // Verify recording captured both calls
+        const sequence = ctx.getToolCallSequence();
+        expect(sequence.length).toBeGreaterThanOrEqual(2);
+        expect(sequence[0]).toBe("get-project-info");
+        expect(sequence[1]).toBe("get-project-info");
+
+        // assertToolOrder should not throw
+        expect(() => ctx.assertToolOrder(["get-project-info", "get-project-info"])).not.toThrow();
+    });
+
+    it("records messages in both directions", async () => {
+        const ctx = await createRecordingMcpTestContext();
+        cleanup = ctx.cleanup;
+
+        const { dir, cleanup: tempCleanup } = createTempMendixProject();
+        tempCleanups.push(tempCleanup);
+        ctx.state.projectDir = dir;
+
+        await ctx.client.callTool({ name: "get-project-info", arguments: {} });
+
+        const clientToServer = ctx.records.filter(r => r.direction === "client-to-server");
+        const serverToClient = ctx.records.filter(r => r.direction === "server-to-client");
+
+        expect(clientToServer.length).toBeGreaterThan(0);
+        expect(serverToClient.length).toBeGreaterThan(0);
+    });
+
+    it("getToolCalls returns name and arguments", async () => {
+        const ctx = await createRecordingMcpTestContext();
+        cleanup = ctx.cleanup;
+
+        const { dir, cleanup: tempCleanup } = createTempMendixProject();
+        tempCleanups.push(tempCleanup);
+
+        await ctx.client.callTool({
+            name: "set-project-directory",
+            arguments: { projectDir: dir }
+        });
+
+        const toolCalls = ctx.getToolCalls();
+        expect(toolCalls).toHaveLength(1);
+        expect(toolCalls[0].name).toBe("set-project-directory");
+        expect((toolCalls[0].arguments as Record<string, unknown>).projectDir).toBe(dir);
+        expect(toolCalls[0].timestamp).toBeGreaterThan(0);
+    });
+
+    it("assertToolOrder throws when sequence is wrong", async () => {
+        const ctx = await createRecordingMcpTestContext();
+        cleanup = ctx.cleanup;
+
+        const { dir, cleanup: tempCleanup } = createTempMendixProject();
+        tempCleanups.push(tempCleanup);
+        ctx.state.projectDir = dir;
+
+        await ctx.client.callTool({ name: "get-project-info", arguments: {} });
+
+        expect(() => ctx.assertToolOrder(["set-project-directory"])).toThrow();
+    });
+});