retestkit 1.4.1

package/src/test-utils/mock-playwright-client.ts

@@ -0,0 +1,422 @@
+/**
+ * Mock Playwright MCP Client for testing
+ *
+ * Provides a controllable mock implementation of PlaywrightClient
+ * for testing crawl, test execution, and other Playwright-dependent flows.
+ */
+
+import { vi } from "vitest";
+import type {
+  PlaywrightClient,
+  PlaywrightSnapshot,
+  PlaywrightScreenshot,
+} from "../playwright-client/index.js";
+import type { PlaywrightToolMapping, PlaywrightToolCallResult } from "../playwright-client/types.js";
+
+export interface MockPage {
+  url: string;
+  title: string;
+  html: string;
+  links?: Array<{ selector: string; href: string; text: string }>;
+  forms?: Array<{ selector: string; action: string; inputs: string[] }>;
+  buttons?: Array<{ selector: string; text: string }>;
+}
+
+export interface MockPlaywrightClientOptions {
+  /** Starting pages - keyed by URL */
+  pages: Record<string, MockPage>;
+  /** Custom tool call handler for testing specific behaviors */
+  onToolCall?: (
+    tool: keyof PlaywrightToolMapping,
+    args: Record<string, unknown>
+  ) => PlaywrightToolCallResult | undefined;
+  /** Simulated errors by tool name */
+  errors?: Partial<Record<keyof PlaywrightToolMapping, string>>;
+  /** Delay in ms to simulate network latency */
+  latencyMs?: number;
+}
+
+export interface MockPlaywrightClient extends PlaywrightClient {
+  /** Get the current page state */
+  getCurrentPage(): MockPage | undefined;
+  /** Set custom pages for testing */
+  setPages(pages: Record<string, MockPage>): void;
+  /** Get action history */
+  getActionHistory(): Array<{ tool: string; args: Record<string, unknown> }>;
+  /** Clear action history */
+  clearActionHistory(): void;
+  /** Set error for specific tool */
+  setError(tool: keyof PlaywrightToolMapping, message: string | null): void;
+}
+
+export function createMockPlaywrightClient(
+  options: MockPlaywrightClientOptions
+): MockPlaywrightClient {
+  let pages = { ...options.pages };
+  let currentUrl: string | undefined;
+  let connected = false;
+  const actionHistory: Array<{ tool: string; args: Record<string, unknown> }> = [];
+  const errors: Partial<Record<keyof PlaywrightToolMapping, string>> = {
+    ...options.errors,
+  };
+
+  const toolMapping: PlaywrightToolMapping = {
+    snapshot: "browser_snapshot",
+    screenshot: "browser_take_screenshot",
+    click: "browser_click",
+    type: "browser_type",
+    navigate: "browser_navigate",
+    fill: "browser_type", // Microsoft Playwright MCP uses browser_type for fill
+    hover: "browser_hover",
+    select: "browser_select_option",
+    evaluate: "browser_evaluate",
+    press: "browser_press_key",
+    scroll: "browser_scroll",
+    wait: "browser_wait",
+  };
+
+  function getCurrentPage(): MockPage | undefined {
+    if (!currentUrl) return undefined;
+    return pages[currentUrl];
+  }
+
+  async function delay(): Promise<void> {
+    if (options.latencyMs) {
+      await new Promise((resolve) => setTimeout(resolve, options.latencyMs));
+    }
+  }
+
+  function recordAction(tool: string, args: Record<string, unknown>): void {
+    actionHistory.push({ tool, args });
+  }
+
+  const client: MockPlaywrightClient = {
+    connect: vi.fn().mockImplementation(async () => {
+      await delay();
+      connected = true;
+    }),
+
+    disconnect: vi.fn().mockImplementation(async () => {
+      await delay();
+      connected = false;
+      currentUrl = undefined;
+    }),
+
+    isConnected: vi.fn().mockImplementation(() => {
+      return connected;
+    }),
+
+    getToolMapping: vi.fn().mockImplementation(() => {
+      return connected ? toolMapping : null;
+    }),
+
+    callTool: vi.fn().mockImplementation(async (
+      canonicalName: keyof PlaywrightToolMapping,
+      args: Record<string, unknown>
+    ): Promise<PlaywrightToolCallResult> => {
+      await delay();
+      recordAction(canonicalName, args);
+
+      // Check for configured errors
+      if (errors[canonicalName]) {
+        return {
+          content: [{ type: "text", text: `Error: ${errors[canonicalName]}` }],
+          isError: true,
+        };
+      }
+
+      // Check for custom handler
+      if (options.onToolCall) {
+        const customResult = options.onToolCall(canonicalName, args);
+        if (customResult) return customResult;
+      }
+
+      // Default implementations
+      const actualName = toolMapping[canonicalName];
+      return {
+        content: [{ type: "text", text: `${actualName} executed successfully` }],
+      };
+    }),
+
+    snapshot: vi.fn().mockImplementation(async (): Promise<PlaywrightSnapshot> => {
+      await delay();
+      recordAction("snapshot", {});
+
+      if (errors.snapshot) {
+        throw new Error(errors.snapshot);
+      }
+
+      const page = getCurrentPage();
+      if (!page) {
+        return {
+          url: currentUrl || "",
+          title: "",
+          content: "No page loaded",
+        };
+      }
+
+      return {
+        url: page.url,
+        title: page.title,
+        content: JSON.stringify({
+          url: page.url,
+          title: page.title,
+          links: page.links,
+          forms: page.forms,
+          buttons: page.buttons,
+        }),
+      };
+    }),
+
+    screenshot: vi.fn().mockImplementation(async (): Promise<PlaywrightScreenshot> => {
+      await delay();
+      recordAction("screenshot", {});
+
+      if (errors.screenshot) {
+        throw new Error(errors.screenshot);
+      }
+
+      // Return a minimal valid PNG (1x1 transparent pixel)
+      const minimalPng =
+        "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mNk+M9QDwADhgGAWjR9awAAAABJRU5ErkJggg==";
+
+      return {
+        data: minimalPng,
+        mimeType: "image/png",
+      };
+    }),
+
+    navigate: vi.fn().mockImplementation(async (url: string): Promise<void> => {
+      await delay();
+      recordAction("navigate", { url });
+
+      if (errors.navigate) {
+        throw new Error(errors.navigate);
+      }
+
+      currentUrl = url;
+
+      // Auto-create a default page if not defined
+      if (!pages[url]) {
+        pages[url] = {
+          url,
+          title: `Page: ${url}`,
+          html: `<html><head><title>Page: ${url}</title></head><body></body></html>`,
+        };
+      }
+    }),
+
+    click: vi.fn().mockImplementation(async (element: string, ref: string): Promise<void> => {
+      await delay();
+      recordAction("click", { element, ref });
+
+      if (errors.click) {
+        throw new Error(errors.click);
+      }
+
+      // Check if clicking a link triggers navigation (use ref as selector for mock lookup)
+      const page = getCurrentPage();
+      if (page?.links) {
+        const link = page.links.find((l) => l.selector === ref || l.text === element);
+        if (link?.href) {
+          currentUrl = link.href;
+        }
+      }
+    }),
+
+    type: vi.fn().mockImplementation(async (
+      element: string,
+      ref: string,
+      text: string,
+      options?: { submit?: boolean; slowly?: boolean }
+    ): Promise<void> => {
+      await delay();
+      recordAction("type", { element, ref, text, submit: options?.submit, slowly: options?.slowly });
+
+      if (errors.type) {
+        throw new Error(errors.type);
+      }
+    }),
+
+    fill: vi.fn().mockImplementation(async (element: string, ref: string, value: string): Promise<void> => {
+      await delay();
+      recordAction("fill", { element, ref, value });
+
+      if (errors.fill) {
+        throw new Error(errors.fill);
+      }
+    }),
+
+    hover: vi.fn().mockImplementation(async (element: string, ref: string): Promise<void> => {
+      await delay();
+      recordAction("hover", { element, ref });
+
+      if (errors.hover) {
+        throw new Error(errors.hover);
+      }
+    }),
+
+    select: vi.fn().mockImplementation(async (element: string, ref: string, values: string[]): Promise<void> => {
+      await delay();
+      recordAction("select", { element, ref, values });
+
+      if (errors.select) {
+        throw new Error(errors.select);
+      }
+    }),
+
+    evaluate: vi.fn().mockImplementation(async (fn: string, element?: string, ref?: string): Promise<unknown> => {
+      await delay();
+      const args: Record<string, unknown> = { function: fn };
+      if (element) args.element = element;
+      if (ref) args.ref = ref;
+      recordAction("evaluate", args);
+
+      if (errors.evaluate) {
+        throw new Error(errors.evaluate);
+      }
+
+      // Return the current page HTML as a default evaluation result
+      const page = getCurrentPage();
+      return page?.html || "";
+    }),
+
+    press: vi.fn().mockImplementation(async (key: string): Promise<void> => {
+      await delay();
+      recordAction("press", { key });
+
+      if (errors.press) {
+        throw new Error(errors.press);
+      }
+    }),
+
+    scroll: vi.fn().mockImplementation(async (x: number, y: number): Promise<void> => {
+      await delay();
+      recordAction("scroll", { x, y });
+
+      if (errors.scroll) {
+        throw new Error(errors.scroll);
+      }
+    }),
+
+    wait: vi.fn().mockImplementation(async (ms: number): Promise<void> => {
+      await delay();
+      recordAction("wait", { ms });
+
+      if (errors.wait) {
+        throw new Error(errors.wait);
+      }
+
+      // Actually wait for the specified time
+      await new Promise((resolve) => setTimeout(resolve, ms));
+    }),
+
+    // Test helpers
+    getCurrentPage,
+
+    setPages(newPages: Record<string, MockPage>): void {
+      pages = { ...newPages };
+    },
+
+    getActionHistory(): Array<{ tool: string; args: Record<string, unknown> }> {
+      return [...actionHistory];
+    },
+
+    clearActionHistory(): void {
+      actionHistory.length = 0;
+    },
+
+    setError(tool: keyof PlaywrightToolMapping, message: string | null): void {
+      if (message === null) {
+        delete errors[tool];
+      } else {
+        errors[tool] = message;
+      }
+    },
+  };
+
+  return client;
+}
+
+/**
+ * Create a simple mock page for testing
+ */
+export function createMockPage(
+  url: string,
+  options: Partial<MockPage> = {}
+): MockPage {
+  const hostname = new URL(url).hostname;
+  return {
+    url,
+    title: options.title || `Page - ${hostname}`,
+    html:
+      options.html ||
+      `<html><head><title>${options.title || hostname}</title></head><body><h1>Welcome</h1></body></html>`,
+    links: options.links || [],
+    forms: options.forms || [],
+    buttons: options.buttons || [],
+  };
+}
+
+/**
+ * Create a typical e-commerce site mock for testing
+ */
+export function createEcommerceMock(): Record<string, MockPage> {
+  const baseUrl = "https://shop.example.com";
+
+  return {
+    [baseUrl]: createMockPage(baseUrl, {
+      title: "Shop - Home",
+      links: [
+        { selector: 'a[href="/products"]', href: `${baseUrl}/products`, text: "Products" },
+        { selector: 'a[href="/cart"]', href: `${baseUrl}/cart`, text: "Cart" },
+        { selector: 'a[href="/login"]', href: `${baseUrl}/login`, text: "Login" },
+      ],
+      buttons: [{ selector: "button.search", text: "Search" }],
+    }),
+    [`${baseUrl}/products`]: createMockPage(`${baseUrl}/products`, {
+      title: "Shop - Products",
+      links: [
+        { selector: 'a[href="/"]', href: baseUrl, text: "Home" },
+        { selector: 'a[href="/product/1"]', href: `${baseUrl}/product/1`, text: "Product 1" },
+        { selector: 'a[href="/product/2"]', href: `${baseUrl}/product/2`, text: "Product 2" },
+      ],
+    }),
+    [`${baseUrl}/product/1`]: createMockPage(`${baseUrl}/product/1`, {
+      title: "Product 1 - Shop",
+      buttons: [
+        { selector: "button.add-to-cart", text: "Add to Cart" },
+        { selector: "button.buy-now", text: "Buy Now" },
+      ],
+    }),
+    [`${baseUrl}/cart`]: createMockPage(`${baseUrl}/cart`, {
+      title: "Shopping Cart - Shop",
+      buttons: [
+        { selector: "button.checkout", text: "Checkout" },
+        { selector: "button.continue-shopping", text: "Continue Shopping" },
+      ],
+    }),
+    [`${baseUrl}/login`]: createMockPage(`${baseUrl}/login`, {
+      title: "Login - Shop",
+      forms: [
+        {
+          selector: "form#login",
+          action: "/auth/login",
+          inputs: ["email", "password"],
+        },
+      ],
+      buttons: [{ selector: "button.submit", text: "Sign In" }],
+    }),
+    [`${baseUrl}/checkout`]: createMockPage(`${baseUrl}/checkout`, {
+      title: "Checkout - Shop",
+      forms: [
+        {
+          selector: "form#checkout",
+          action: "/process-order",
+          inputs: ["name", "address", "card"],
+        },
+      ],
+      buttons: [{ selector: "button.place-order", text: "Place Order" }],
+    }),
+  };
+}

package/src/tools/index.ts

@@ -0,0 +1,11 @@
+// Tools are now registered directly in server.ts via the webtest tools
+// This file is kept for backwards compatibility but tools array is empty
+// The hello tool has been removed as part of the webtest orchestrator implementation
+
+import type { McpTool } from "../types/tool.js";
+
+// Webtest tools are exported from the webtest module
+export * from "./webtest/index.js";
+
+// Legacy tools array - empty since webtest tools are registered differently
+export const tools: McpTool[] = [];