retestkit 1.4.1

package/src/test-utils/mock-context.ts

@@ -0,0 +1,426 @@
+/**
+ * Mock context utilities for testing webtest tools
+ */
+
+import { vi } from "vitest";
+import type { Logger } from "../logger.js";
+import type { Config } from "../schemas/config.js";
+import type { ClientCapabilities } from "../types/capabilities.js";
+import type { WorkspaceManager } from "../workspace/index.js";
+import type { ResourceManager } from "../resources/index.js";
+import type { SamplingClient } from "../sampling/index.js";
+import type { ElicitationClient } from "../elicitation/index.js";
+import type { ProgressEmitter, CancellationRegistry } from "../progress/index.js";
+import type { SecurityValidator } from "../security/index.js";
+import type { PlaywrightClient } from "../playwright-client/index.js";
+import {
+  createMockPlaywrightClient,
+  createEcommerceMock,
+  type MockPlaywrightClient,
+} from "./mock-playwright-client.js";
+
+// MockContext interface is defined at the end of the file
+
+export function createMockLogger(): Logger {
+  return {
+    debug: vi.fn(),
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    setLevel: vi.fn(),
+    withCorrelation: vi.fn().mockReturnThis(),
+  } as unknown as Logger;
+}
+
+export function createMockConfig(overrides: Partial<Config> = {}): Config {
+  return {
+    transport: "stdio" as const,
+    port: 3000,
+    logLevel: "info" as const,
+    workspaceDir: "/tmp/webtest-workspaces",
+    playwrightMcpCommand: "npx",
+    playwrightMcpArgs: ["@playwright/mcp@latest"],
+    checkpointInterval: 5,
+    screenshotFormat: "png" as const,
+    screenshotQuality: 80,
+    defaultMaxSteps: 50,
+    defaultMaxMinutes: 30,
+    defaultMaxPages: 20,
+    ...overrides,
+  };
+}
+
+export function createMockCapabilities(
+  overrides: Partial<ClientCapabilities> = {}
+): ClientCapabilities {
+  return {
+    sampling: true,
+    elicitation: true,
+    logging: true,
+    progress: true,
+    resourcesListChanged: true,
+    resourcesSubscribe: true,
+    protocolVersion: "2025-06-18",
+    ...overrides,
+  };
+}
+
+export function createMockWorkspaceManager(): WorkspaceManager {
+  const workspaces: Map<string, any> = new Map();
+  const crawls: Map<string, any> = new Map();
+  const runs: Map<string, any> = new Map();
+
+  return {
+    createWorkspace: vi.fn().mockImplementation(async (params) => {
+      const analysisId = `analysis-${Date.now()}`;
+      const workspacePath = `/tmp/webtest-workspaces/${analysisId}`;
+      workspaces.set(analysisId, {
+        analysisId,
+        url: params.url,
+        domain: new URL(params.url).hostname,
+        focus: params.focus,
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        status: "active",
+        limits: params.limits,
+        crawls: [],
+        runs: [],
+      });
+      return { analysisId, workspacePath };
+    }),
+
+    getWorkspacePath: vi.fn().mockImplementation((analysisId) => {
+      return `/tmp/webtest-workspaces/${analysisId}`;
+    }),
+
+    workspaceExists: vi.fn().mockImplementation(async (analysisId) => {
+      return workspaces.has(analysisId);
+    }),
+
+    readWorkspaceIndex: vi.fn().mockImplementation(async (analysisId) => {
+      const workspace = workspaces.get(analysisId);
+      if (!workspace) throw new Error(`Workspace ${analysisId} not found`);
+      return workspace;
+    }),
+
+    updateWorkspaceIndex: vi.fn().mockImplementation(async (analysisId, update) => {
+      const workspace = workspaces.get(analysisId);
+      if (workspace) {
+        Object.assign(workspace, update, { updatedAt: new Date().toISOString() });
+      }
+    }),
+
+    createCrawl: vi.fn().mockImplementation(async (analysisId, params) => {
+      const crawlId = `crawl-${Date.now()}`;
+      const crawlPath = `/tmp/webtest-workspaces/${analysisId}/crawls/${crawlId}`;
+      const crawlIndex = {
+        crawlId,
+        analysisId,
+        goal: params.goal,
+        strategy: params.strategy,
+        status: "in_progress",
+        startedAt: new Date().toISOString(),
+        budget: {
+          ...params.limits,
+          stepsUsed: 0,
+          pagesVisited: 0,
+        },
+        pages: [],
+        actionHistory: [],
+        loopDetection: {
+          domSignatures: {},
+          urlVisits: {},
+          recentActions: [],
+        },
+      };
+      crawls.set(`${analysisId}:${crawlId}`, crawlIndex);
+
+      // Update workspace
+      const workspace = workspaces.get(analysisId);
+      if (workspace) {
+        workspace.crawls.push({
+          crawlId,
+          goal: params.goal,
+          status: "in_progress",
+          startedAt: crawlIndex.startedAt,
+          pagesVisited: 0,
+          stepsExecuted: 0,
+        });
+      }
+
+      return { crawlId, crawlPath };
+    }),
+
+    getCrawlPath: vi.fn().mockImplementation((analysisId, crawlId) => {
+      return `/tmp/webtest-workspaces/${analysisId}/crawls/${crawlId}`;
+    }),
+
+    readCrawlIndex: vi.fn().mockImplementation(async (analysisId, crawlId) => {
+      const crawl = crawls.get(`${analysisId}:${crawlId}`);
+      if (!crawl) throw new Error(`Crawl ${crawlId} not found`);
+      return crawl;
+    }),
+
+    updateCrawlIndex: vi.fn().mockImplementation(async (analysisId, crawlId, update) => {
+      const crawl = crawls.get(`${analysisId}:${crawlId}`);
+      if (crawl) {
+        Object.assign(crawl, update);
+      }
+    }),
+
+    savePage: vi.fn().mockImplementation(async (analysisId, crawlId, page) => {
+      const pageId = `page-${Date.now()}`;
+      const pagesDir = `/tmp/webtest-workspaces/${analysisId}/crawls/${crawlId}/pages/${pageId}`;
+      const pageRef = {
+        pageId,
+        url: page.url,
+        title: page.title,
+        capturedAt: new Date().toISOString(),
+        snapshotFilePath: `${pagesDir}/snapshot.json`,
+        snapshotUri: `webtest://${analysisId}/crawls/${crawlId}/pages/${pageId}/snapshot.json`,
+        screenshotFilePath: `${pagesDir}/screenshot.png`,
+        screenshotUri: `webtest://${analysisId}/crawls/${crawlId}/pages/${pageId}/screenshot.png`,
+        domFilePath: `${pagesDir}/dom.html`,
+        domUri: `webtest://${analysisId}/crawls/${crawlId}/pages/${pageId}/dom.html`,
+      };
+
+      const crawl = crawls.get(`${analysisId}:${crawlId}`);
+      if (crawl) {
+        crawl.pages.push(pageRef);
+        crawl.budget.pagesVisited = crawl.pages.length;
+      }
+
+      return pageRef;
+    }),
+
+    saveCheckpoint: vi.fn().mockResolvedValue(undefined),
+    loadCheckpoint: vi.fn().mockResolvedValue(null),
+    recordAction: vi.fn().mockResolvedValue(undefined),
+    saveAnalysis: vi.fn().mockImplementation(async (analysisId) => ({
+      appAnalysisFilePath: `/tmp/webtest-workspaces/${analysisId}/analysis/app-analysis.md`,
+      appAnalysisUri: `webtest://${analysisId}/analysis/app-analysis.md`,
+      flowsFilePath: `/tmp/webtest-workspaces/${analysisId}/analysis/flows.md`,
+      flowsUri: `webtest://${analysisId}/analysis/flows.md`,
+    })),
+    saveTests: vi.fn().mockImplementation(async (analysisId, tests) => ({
+      testsFilePath: `/tmp/webtest-workspaces/${analysisId}/tests/tests.md`,
+      testsUri: `webtest://${analysisId}/tests/tests.md`,
+      testCount: (tests.frontmatter as any)?.tests?.length || 0,
+    })),
+    createTestRun: vi.fn().mockImplementation(async (analysisId, params) => {
+      const runId = `run-${Date.now()}`;
+      const runPath = `/tmp/webtest-workspaces/${analysisId}/runs/${runId}`;
+      runs.set(`${analysisId}:${runId}`, {
+        runId,
+        analysisId,
+        testCaseId: params.testCaseId,
+        testName: params.testName,
+        status: "in_progress",
+        startedAt: new Date().toISOString(),
+        steps: [],
+      });
+      return { runId, runPath };
+    }),
+    getTestRunPath: vi.fn().mockImplementation((analysisId, runId) => {
+      return `/tmp/webtest-workspaces/${analysisId}/runs/${runId}`;
+    }),
+    readTestRunIndex: vi.fn().mockImplementation(async (analysisId, runId) => {
+      const run = runs.get(`${analysisId}:${runId}`);
+      if (!run) throw new Error(`Run ${runId} not found`);
+      return run;
+    }),
+    updateTestRunIndex: vi.fn().mockResolvedValue(undefined),
+    saveTestStepEvidence: vi.fn().mockImplementation(async (analysisId, runId, stepNumber) => ({
+      screenshotFilePath: `/tmp/webtest-workspaces/${analysisId}/runs/${runId}/steps/${stepNumber}/screenshot.png`,
+      screenshotUri: `webtest://${analysisId}/runs/${runId}/steps/${stepNumber}/screenshot.png`,
+      snapshotFilePath: `/tmp/webtest-workspaces/${analysisId}/runs/${runId}/steps/${stepNumber}/snapshot.json`,
+      snapshotUri: `webtest://${analysisId}/runs/${runId}/steps/${stepNumber}/snapshot.json`,
+    })),
+    listWorkspaces: vi.fn().mockResolvedValue([]),
+  } as unknown as WorkspaceManager;
+}
+
+export function createMockResourceManager(): ResourceManager & { [key: string]: any } {
+  return {
+    notifyListChanged: vi.fn(),
+    notifyResourceUpdated: vi.fn(),
+    readResource: vi.fn().mockResolvedValue({
+      text: JSON.stringify({
+        url: "https://shop.example.com",
+        title: "Mock Page",
+        content: "<html><body>Mock content</body></html>",
+      }),
+    }),
+  } as unknown as ResourceManager;
+}
+
+export function createMockSamplingClient(
+  responseGenerator?: (
+    systemPrompt: string,
+    userPrompt: string
+  ) => unknown
+): SamplingClient {
+  return {
+    hasSampling: vi.fn().mockReturnValue(true),
+    createMessage: vi.fn().mockImplementation(async (options) => {
+      if (responseGenerator) {
+        const data = responseGenerator(options.systemPrompt, options.userPrompt);
+        return { success: true, data, rawResponse: JSON.stringify(data) };
+      }
+
+      // Default: return a simple action
+      return {
+        success: true,
+        data: {
+          actions: [],
+          reasoning: "Mock response",
+          goalProgress: "Making progress",
+          goalComplete: false,
+        },
+        rawResponse: "{}",
+      };
+    }),
+  } as unknown as SamplingClient;
+}
+
+export function createMockElicitationClient(): ElicitationClient {
+  return {
+    hasElicitation: vi.fn().mockReturnValue(true),
+    elicit: vi.fn().mockResolvedValue({ success: true, selectedValue: "accept" }),
+    createCookieConsentRequest: vi.fn(),
+    createModalBlockingRequest: vi.fn(),
+    createAmbiguousNavigationRequest: vi.fn(),
+    createAuthRequiredRequest: vi.fn(),
+  } as unknown as ElicitationClient;
+}
+
+export function createMockProgressEmitter(): ProgressEmitter {
+  return {
+    emit: vi.fn(),
+    hasProgress: vi.fn().mockReturnValue(true),
+  } as unknown as ProgressEmitter;
+}
+
+export function createMockCancellationRegistry(): CancellationRegistry {
+  const cancelled = new Set<string>();
+
+  return {
+    register: vi.fn(),
+    unregister: vi.fn(),
+    isCancelled: vi.fn().mockImplementation((id) => cancelled.has(id)),
+    cancel: vi.fn().mockImplementation((id) => cancelled.add(id)),
+    checkCancelled: vi.fn().mockImplementation((id) => {
+      if (cancelled.has(id)) {
+        throw new Error(`Request ${id} was cancelled`);
+      }
+    }),
+  } as unknown as CancellationRegistry;
+}
+
+export function createMockSecurityValidator(): SecurityValidator {
+  return {
+    validateDomain: vi.fn().mockReturnValue({ valid: true }),
+    validateAction: vi.fn().mockReturnValue({ valid: true }),
+    detectInjectionAttempt: vi.fn().mockReturnValue({ detected: false }),
+    detectExfiltrationAttempt: vi.fn().mockReturnValue({ detected: false }),
+  } as unknown as SecurityValidator;
+}
+
+export interface MockContext {
+  config: Config;
+  logger: Logger;
+  capabilities: ClientCapabilities;
+  playwrightClient: MockPlaywrightClient;
+  workspaceManager: WorkspaceManager & { [key: string]: any };
+  resourceManager: ResourceManager & { [key: string]: any };
+  samplingClient: SamplingClient & { [key: string]: any };
+  elicitationClient: ElicitationClient & { [key: string]: any };
+  progressEmitter: ProgressEmitter & { [key: string]: any };
+  cancellationRegistry: CancellationRegistry & { [key: string]: any };
+  securityValidator: SecurityValidator & { [key: string]: any };
+  // Test helper properties
+  testAnalysisId: string;
+  testCrawlId: string;
+}
+
+/**
+ * Create a complete mock context for testing webtest tools
+ */
+export function createMockContext(
+  overrides: Partial<{
+    config: Partial<Config>;
+    capabilities: Partial<ClientCapabilities>;
+    samplingResponseGenerator: (
+      systemPrompt: string,
+      userPrompt: string
+    ) => unknown;
+    playwrightPages: Record<string, import("./mock-playwright-client.js").MockPage>;
+  }> = {}
+): MockContext {
+  const playwrightClient = createMockPlaywrightClient({
+    pages: overrides.playwrightPages || createEcommerceMock(),
+  });
+
+  // Use date-time format for test IDs (matches new workspace folder naming)
+  const testAnalysisId = "2024-01-15_10-30";
+  const testCrawlId = "2024-01-15_10-30-45";
+
+  const workspaceManager = createMockWorkspaceManager();
+
+  // Pre-register test workspace
+  (workspaceManager.workspaceExists as any).mockResolvedValue(true);
+  (workspaceManager.readWorkspaceIndex as any).mockResolvedValue({
+    url: "https://shop.example.com",
+    domain: "shop.example.com",
+    focus: "Test focus",
+    crawls: [
+      {
+        crawlId: testCrawlId,
+        goal: "Explore",
+        status: "completed",
+        startedAt: new Date().toISOString(),
+        completedAt: new Date().toISOString(),
+        pagesVisited: 2,
+        stepsExecuted: 5,
+      },
+    ],
+    runs: [],
+    limits: {
+      maxSteps: 50,
+      maxMinutes: 30,
+      maxPages: 20,
+    },
+  });
+
+  (workspaceManager.readCrawlIndex as any).mockResolvedValue({
+    crawlId: testCrawlId,
+    goal: "Explore",
+    strategy: "goal_directed",
+    status: "completed",
+    pages: [
+      {
+        pageId: "page-1",
+        url: "https://shop.example.com",
+        title: "Home",
+        snapshotUri: `webtest://${testAnalysisId}/crawls/${testCrawlId}/pages/page-1/snapshot.md`,
+      },
+    ],
+    actionHistory: [],
+  });
+
+  return {
+    config: createMockConfig(overrides.config),
+    logger: createMockLogger(),
+    capabilities: createMockCapabilities(overrides.capabilities),
+    playwrightClient,
+    workspaceManager,
+    resourceManager: createMockResourceManager(),
+    samplingClient: createMockSamplingClient(overrides.samplingResponseGenerator),
+    elicitationClient: createMockElicitationClient(),
+    progressEmitter: createMockProgressEmitter(),
+    cancellationRegistry: createMockCancellationRegistry(),
+    securityValidator: createMockSecurityValidator(),
+    testAnalysisId,
+    testCrawlId,
+  };
+}