openclaw-multi-auto 1.4.6 → 1.4.7

package/extensions/page-action-cache/tests/actions-executor.test.ts

@@ -0,0 +1,424 @@
+/**
+ * Actions Executor Tests
+ */
+
+import { describe, it, expect, beforeEach, vi } from "vitest";
+import { ActionsExecutor } from "../src/actions-executor.js";
+import type { AtomicAction, PwAi, VariableMap } from "../src/types.js";
+
+// Mock Playwright client
+const mockPwAi = {
+  navigateViaPlaywright: vi.fn(),
+  clickViaPlaywright: vi.fn(),
+  typeViaPlaywright: vi.fn(),
+  pressKeyViaPlaywright: vi.fn(),
+  hoverViaPlaywright: vi.fn(),
+  screenshotViaPlaywright: vi.fn(),
+  evaluateViaPlaywright: vi.fn(),
+} as unknown as PwAi;
+
+describe("ActionsExecutor", () => {
+  let executor: ActionsExecutor;
+
+  beforeEach(() => {
+    executor = new ActionsExecutor("http://localhost:9222");
+    executor.setPlaywrightClient(mockPwAi);
+    vi.clearAllMocks();
+  });
+
+  describe("executeNavigate", () => {
+    it("should execute navigate action", async () => {
+      const action = {
+        type: "navigate" as const,
+        url: "https://example.com",
+        order: 1,
+      };
+
+      const result = await executor.execute(action);
+
+      expect(result.success).toBe(true);
+      expect(result.action).toBe("navigate");
+      expect(mockPwAi.navigateViaPlaywright).toHaveBeenCalledWith({
+        cdpUrl: "http://localhost:9222",
+        targetId: undefined,
+        url: "https://example.com",
+        waitUntil: "domcontentloaded",
+        timeout: undefined,
+      });
+    });
+
+    it("should use custom navigation policy", async () => {
+      const action = {
+        type: "navigate" as const,
+        url: "https://example.com",
+        order: 1,
+        navigationPolicy: {
+          waitUntil: "load" as const,
+          timeout: 30000,
+        },
+      };
+
+      const result = await executor.execute(action);
+
+      expect(result.success).toBe(true);
+      expect(mockPwAi.navigateViaPlaywright).toHaveBeenCalledWith({
+        cdpUrl: "http://localhost:9222",
+        targetId: undefined,
+        url: "https://example.com",
+        waitUntil: "load",
+        timeout: 30000,
+      });
+    });
+  });
+
+  describe("executeClick", () => {
+    it("should execute click action", async () => {
+      const action = {
+        type: "click" as const,
+        ref: "#submit-button",
+        order: 1,
+      };
+
+      const result = await executor.execute(action);
+
+      expect(result.success).toBe(true);
+      expect(result.action).toBe("click");
+      expect(mockPwAi.clickViaPlaywright).toHaveBeenCalledWith({
+        cdpUrl: "http://localhost:9222",
+        targetId: undefined,
+        ref: "#submit-button",
+        doubleClick: undefined,
+        button: "left",
+        modifiers: undefined,
+        timeoutMs: undefined,
+      });
+    });
+
+    it("should execute double click", async () => {
+      const action = {
+        type: "click" as const,
+        ref: "#button",
+        doubleClick: true,
+        order: 1,
+      };
+
+      const result = await executor.execute(action);
+
+      expect(result.success).toBe(true);
+      expect(mockPwAi.clickViaPlaywright).toHaveBeenCalledWith(
+        expect.objectContaining({
+          doubleClick: true,
+        })
+      );
+    });
+
+    it("should execute click with modifiers", async () => {
+      const action = {
+        type: "click" as const,
+        ref: "#button",
+        button: "left" as const,
+        modifiers: ["Control", "Shift"],
+        order: 1,
+      };
+
+      const result = await executor.execute(action);
+
+      expect(result.success).toBe(true);
+      expect(mockPwAi.clickViaPlaywright).toHaveBeenCalledWith(
+        expect.objectContaining({
+          button: "left",
+          modifiers: ["Control", "Shift"],
+        })
+      );
+    });
+  });
+
+  describe("executeType", () => {
+    it("should execute type action", async () => {
+      const action = {
+        type: "type" as const,
+        ref: "#username",
+        text: "alice",
+        order: 1,
+      };
+
+      const result = await executor.execute(action);
+
+      expect(result.success).toBe(true);
+      expect(result.action).toBe("type");
+      expect(mockPwAi.typeViaPlaywright).toHaveBeenCalledWith({
+        cdpUrl: "http://localhost:9222",
+        targetId: undefined,
+        ref: "#username",
+        text: "alice",
+        submit: undefined,
+        slowly: undefined,
+        timeoutMs: undefined,
+      });
+    });
+
+    it("should execute type with submit", async () => {
+      const action = {
+        type: "type" as const,
+        ref: "#username",
+        text: "alice",
+        submit: true,
+        order: 1,
+      };
+
+      const result = await executor.execute(action);
+
+      expect(result.success).toBe(true);
+      expect(mockPwAi.typeViaPlaywright).toHaveBeenCalledWith(
+        expect.objectContaining({
+          submit: true,
+        })
+      );
+    });
+
+    it("should execute type with slowly", async () => {
+      const action = {
+        type: "type" as const,
+        ref: "#username",
+        text: "alice",
+        slowly: true,
+        order: 1,
+      };
+
+      const result = await executor.execute(action);
+
+      expect(result.success).toBe(true);
+      expect(mockPwAi.typeViaPlaywright).toHaveBeenCalledWith(
+        expect.objectContaining({
+          slowly: true,
+        })
+      );
+    });
+  });
+
+  describe("executePress", () => {
+    it("should execute press action", async () => {
+      const action = {
+        type: "press" as const,
+        key: "Enter",
+        order: 1,
+      };
+
+      const result = await executor.execute(action);
+
+      expect(result.success).toBe(true);
+      expect(result.action).toBe("press");
+      expect(mockPwAi.pressKeyViaPlaywright).toHaveBeenCalledWith({
+        cdpUrl: "http://localhost:9222",
+        targetId: undefined,
+        key: "Enter",
+        delayMs: undefined,
+      });
+    });
+
+    it("should execute press with delay", async () => {
+      const action = {
+        type: "press" as const,
+        key: "Tab",
+        delayMs: 100,
+        order: 1,
+      };
+
+      const result = await executor.execute(action);
+
+      expect(result.success).toBe(true);
+      expect(mockPwAi.pressKeyViaPlaywright).toHaveBeenCalledWith(
+        expect.objectContaining({
+          delayMs: 100,
+        })
+      );
+    });
+  });
+
+  describe("executeHover", () => {
+    it("should execute hover action", async () => {
+      const action = {
+        type: "hover" as const,
+        ref: "#menu",
+        order: 1,
+      };
+
+      const result = await executor.execute(action);
+
+      expect(result.success).toBe(true);
+      expect(result.action).toBe("hover");
+      expect(mockPwAi.hoverViaPlaywright).toHaveBeenCalledWith({
+        cdpUrl: "http://localhost:9222",
+        targetId: undefined,
+        ref: "#menu",
+        timeoutMs: undefined,
+      });
+    });
+  });
+
+  describe("executeEvaluate", () => {
+    it("should execute evaluate action", async () => {
+      const action = {
+        type: "scroll" as const,
+        evaluate: {
+          code: "window.scrollTo(0, 500)",
+        },
+        order: 1,
+      };
+
+      const result = await executor.execute(action);
+
+      expect(result.success).toBe(true);
+      expect(result.action).toBe("scroll");
+      expect(mockPwAi.evaluateViaPlaywright).toHaveBeenCalledWith({
+        cdpUrl: "http://localhost:9222",
+        targetId: undefined,
+        code: "window.scrollTo(0, 500)",
+        args: undefined,
+      });
+    });
+  });
+
+  describe("variable replacement", () => {
+    it("should replace variable in type action", async () => {
+      const action = {
+        type: "type" as const,
+        ref: "#username",
+        variable: "username",
+        order: 1,
+      };
+
+      const variables: VariableMap = { username: "alice" };
+      const result = await executor.execute(action, variables);
+
+      expect(result.success).toBe(true);
+      expect(mockPwAi.typeViaPlaywright).toHaveBeenCalledWith(
+        expect.objectContaining({
+          text: "alice",
+        })
+      );
+    });
+
+    it("should replace variable in press action", async () => {
+      const action = {
+        type: "press" as const,
+        variable: "key",
+        order: 1,
+      };
+
+      const variables: VariableMap = { key: "Enter" };
+      const result = await executor.execute(action, variables);
+
+      expect(result.success).toBe(true);
+      expect(mockPwAi.pressKeyViaPlaywright).toHaveBeenCalledWith(
+        expect.objectContaining({
+          key: "Enter",
+        })
+      );
+    });
+
+    it("should not fail when variable is undefined", async () => {
+      const action = {
+        type: "type" as const,
+        ref: "#username",
+        variable: "username",
+        order: 1,
+      };
+
+      const result = await executor.execute(action);
+
+      // Should execute without error (variable undefined = skip)
+      expect(result.success).toBe(true);
+    });
+  });
+
+  describe("executeBatch", () => {
+    it("should execute multiple actions", async () => {
+      const actions = [
+        { type: "type" as const, ref: "#username", text: "alice", order: 1 },
+        { type: "type" as const, ref: "#password", text: "secret", order: 2 },
+        { type: "press" as const, key: "Enter", order: 3 },
+      ];
+
+      const results = await executor.executeBatch(actions);
+
+      expect(results).toHaveLength(3);
+      expect(results[0].success).toBe(true);
+      expect(results[1].success).toBe(true);
+      expect(results[2].success).toBe(true);
+    });
+
+    it("should support fromIndex and toIndex", async () => {
+      const actions = [
+        { type: "type" as const, ref: "#username", text: "alice", order: 1 },
+        { type: "type" as const, ref: "#password", text: "secret", order: 2 },
+        { type: "press" as const, key: "Enter", order: 3 },
+      ];
+
+      const results = await executor.executeBatch(actions, undefined, {
+        fromIndex: 1,
+        toIndex: 2,
+      });
+
+      expect(results).toHaveLength(2);
+      expect(mockPwAi.typeViaPlaywright).toHaveBeenCalledTimes(2);
+      expect(mockPwAi.pressKeyViaPlaywright).not.toHaveBeenCalled();
+    });
+
+    it("should stop on failure when atomic is true", async () => {
+      const actions = [
+        { type: "type" as const, ref: "#username", text: "alice", order: 1 },
+        { type: "type" as const, ref: "#password", text: "secret", order: 2 },
+        { type: "press" as const, key: "Enter", order: 3 },
+      ];
+
+      // Mock second action to fail
+      vi.mocked(mockPwAi.typeViaPlaywright).mockImplementationOnce(
+        async () => {
+          throw new Error("Element not found");
+        }
+      );
+
+      const results = await executor.executeBatch(actions, undefined, {
+        atomic: true,
+      });
+
+      expect(results).toHaveLength(2); // Only first two executed
+      expect(results[0].success).toBe(true);
+      expect(results[1].success).toBe(false);
+      expect(mockPwAi.pressKeyViaPlaywright).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("formatActions", () => {
+    it("should format actions for display", () => {
+      const actions: AtomicAction[] = [
+        { type: "navigate" as const, url: "https://example.com", order: 1 },
+        { type: "type" as const, ref: "#username", text: "alice", order: 2 },
+        { type: "press" as const, key: "Enter", order: 3 },
+      ];
+
+      const formatted = executor.formatActions(actions);
+
+      expect(formatted).toContain("1. 导航到：https://example.com");
+      expect(formatted).toContain('2. 输入：#username="alice"');
+      expect(formatted).toContain("3. 按键：Enter");
+    });
+  });
+
+  describe("formatExecutionResults", () => {
+    it("should format execution results", () => {
+      const results = [
+        { action: "navigate", success: true, duration: 100 },
+        { action: "click", success: true, duration: 50 },
+        { action: "type", success: false, duration: 200, error: "Timeout" },
+      ];
+
+      const formatted = executor.formatExecutionResults(results);
+
+      expect(formatted).toContain("✅ 操作 1: navigate (100ms)");
+      expect(formatted).toContain("✅ 操作 2: click (50ms)");
+      expect(formatted).toContain("❌ 操作 3: type (200ms) - Timeout");
+    });
+  });
+});

package/extensions/page-action-cache/tests/cache-store.test.ts

@@ -0,0 +1,267 @@
+/**
+ * Cache Store Tests
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { CacheStore } from "../src/cache-store.js";
+
+describe("CacheStore", () => {
+  let cacheStore: CacheStore;
+
+  beforeEach(() => {
+    cacheStore = new CacheStore();
+  });
+
+  afterEach(() => {
+    cacheStore.clear();
+  });
+
+  describe("set and get", () => {
+    it("should save and retrieve cache entry", () => {
+      const url = "https://example.com/login";
+      const viewport = { width: 1920, height: 1080 };
+      const actions = [
+        { type: "type", ref: "#username", text: "test", order: 1 },
+      ];
+
+      const key = cacheStore.set(url, viewport, actions, {
+        scenario: "login",
+        cacheLevel: "L3",
+      });
+
+      expect(key).toBeDefined();
+      expect(typeof key).toBe("string");
+
+      const entry = cacheStore.get(url, viewport);
+      expect(entry).not.toBeNull();
+      expect(entry?.scenario).toBe("login");
+      expect(entry?.cacheLevel).toBe("L3");
+      expect(entry?.actions).toEqual(actions);
+    });
+
+    it("should return null for non-existent cache", () => {
+      const url = "https://example.com/nonexistent";
+      const viewport = { width: 1920, height: 1080 };
+
+      const entry = cacheStore.get(url, viewport);
+      expect(entry).toBeNull();
+    });
+
+    it("should normalize URL", () => {
+      const url1 = "https://example.com/login?param=value";
+      const url2 = "https://example.com/login";
+      const viewport = { width: 1920, height: 1080 };
+      const actions = [];
+
+      cacheStore.set(url1, viewport, actions, {
+        scenario: "login",
+        cacheLevel: "L3",
+      });
+
+      const entry = cacheStore.get(url2, viewport);
+      expect(entry).not.toBeNull();
+    });
+  });
+
+  describe("delete", () => {
+    it("should delete cache entry", () => {
+      const url = "https://example.com/login";
+      const viewport = { width: 1920, height: 1080 };
+      const actions = [];
+
+      cacheStore.set(url, viewport, actions, {
+        scenario: "login",
+        cacheLevel: "L3",
+      });
+
+      const deleted = cacheStore.delete(url, viewport);
+      expect(deleted).toBe(true);
+
+      const entry = cacheStore.get(url, viewport);
+      expect(entry).toBeNull();
+    });
+
+    it("should return false for non-existent cache", () => {
+      const url = "https://example.com/nonexistent";
+      const viewport = { width: 1920, height: 1080 };
+
+      const deleted = cacheStore.delete(url, viewport);
+      expect(deleted).toBe(false);
+    });
+  });
+
+  describe("clear", () => {
+    it("should clear all cache entries", () => {
+      const url1 = "https://example.com/login";
+      const url2 = "https://example.com/search";
+      const viewport = { width: 1920, height: 1080 };
+      const actions = [];
+
+      cacheStore.set(url1, viewport, actions, {
+        scenario: "login",
+        cacheLevel: "L3",
+      });
+      cacheStore.set(url2, viewport, actions, {
+        scenario: "search",
+        cacheLevel: "L3",
+      });
+
+      cacheStore.clear();
+
+      const stats = cacheStore.getStats();
+      expect(stats.totalEntries).toBe(0);
+
+      const entry1 = cacheStore.get(url1, viewport);
+      const entry2 = cacheStore.get(url2, viewport);
+      expect(entry1).toBeNull();
+      expect(entry2).toBeNull();
+    });
+  });
+
+  describe("stats", () => {
+    it("should track hits and misses", () => {
+      const url1 = "https://example.com/login";
+      const url2 = "https://example.com/nonexistent";
+      const viewport = { width: 1920, height: 1080 };
+      const actions = [];
+
+      cacheStore.set(url1, viewport, actions, {
+        scenario: "login",
+        cacheLevel: "L3",
+      });
+
+      // Hit
+      cacheStore.get(url1, viewport);
+
+      // Miss
+      cacheStore.get(url2, viewport);
+
+      const stats = cacheStore.getStats();
+      expect(stats.totalHits).toBe(1);
+      expect(stats.totalMisses).toBe(1);
+      expect(stats.hitRate).toBe(50);
+    });
+
+    it("should calculate hit rate correctly", () => {
+      const url = "https://example.com/login";
+      const viewport = { width: 1920, height: 1080 };
+      const actions = [];
+
+      cacheStore.set(url, viewport, actions, {
+        scenario: "login",
+        cacheLevel: "L3",
+      });
+
+      // 3 hits
+      cacheStore.get(url, viewport);
+      cacheStore.get(url, viewport);
+      cacheStore.get(url, viewport);
+
+      // 1 miss
+      cacheStore.get("https://example.com/nonexistent", viewport);
+
+      const stats = cacheStore.getStats();
+      expect(stats.hitRate).toBe(75);
+    });
+  });
+
+  describe("listEntries", () => {
+    it("should list entries sorted by last access time", () => {
+      const url1 = "https://example.com/login";
+      const url2 = "https://example.com/search";
+      const viewport = { width: 1920, height: 1080 };
+      const actions = [];
+
+      cacheStore.set(url1, viewport, actions, {
+        scenario: "login",
+        cacheLevel: "L3",
+      });
+
+      // Add delay to ensure different timestamps
+      return new Promise<void>((resolve) => {
+        setTimeout(() => {
+          cacheStore.set(url2, viewport, actions, {
+            scenario: "search",
+            cacheLevel: "L3",
+          });
+
+          const entries = cacheStore.listEntries();
+          expect(entries).toHaveLength(2);
+          expect(entries[0].scenario).toBe("search"); // Most recent
+          expect(entries[1].scenario).toBe("login");
+
+          resolve();
+        }, 10);
+      });
+    });
+  });
+
+  describe("cleanupExpired", () => {
+    it("should clean up expired cache entries", () => {
+      const url = "https://example.com/login";
+      const viewport = { width: 1920, height: 1080 };
+      const actions = [];
+
+      // Manually create an expired entry
+      const cacheStoreInstance = cacheStore as any;
+      const key = cacheStoreInstance.generateKey(url, viewport);
+
+      cacheStoreInstance.store.entries[key] = {
+        key,
+        url,
+        viewport,
+        cacheLevel: "L3" as const,
+        scenario: "login",
+        description: "Test",
+        actions,
+        createdAt: Date.now() - 100000000, // Very old
+        lastAccessTime: Date.now() - 100000000,
+        accessCount: 0,
+        expiresAt: Date.now() - 10000, // Expired
+        pageChangeDetection: {
+          hasChanged: false,
+          changeType: "none",
+          confidence: 100,
+          domHash: "",
+          lastCheckedAt: Date.now(),
+        },
+        source: "llm" as const,
+        successCount: 0,
+        failCount: 0,
+        avgExecutionTime: 0,
+      };
+
+      const cleaned = cacheStore.cleanupExpired();
+      expect(cleaned).toBe(1);
+
+      const entry = cacheStore.get(url, viewport);
+      expect(entry).toBeNull();
+    });
+  });
+
+  describe("updateExecutionStats", () => {
+    it("should update execution statistics", () => {
+      const url = "https://example.com/login";
+      const viewport = { width: 1920, height: 1080 };
+      const actions = [];
+
+      const key = cacheStore.set(url, viewport, actions, {
+        scenario: "login",
+        cacheLevel: "L3",
+      });
+
+      const results = [
+        { action: "click", success: true, duration: 100 },
+        { action: "type", success: true, duration: 200 },
+        { action: "click", success: false, duration: 50 },
+      ];
+
+      cacheStore.updateExecutionStats(key, results);
+
+      const entry = cacheStore.get(url, viewport);
+      expect(entry?.successCount).toBe(2);
+      expect(entry?.failCount).toBe(1);
+      expect(entry?.avgExecutionTime).toBeCloseTo(116.67, 1); // (100+200+50)/3
+    });
+  });
+});