retestkit 1.4.1 → 1.5.0

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

@@ -1,426 +0,0 @@
-/**
- * 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,
-  };
-}