retestkit 1.4.1 → 1.5.0

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

@@ -1,422 +0,0 @@
-/**
- * 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

@@ -1,11 +0,0 @@
-// 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[] = [];