openclaw-multi-auto 1.5.2 → 1.5.5

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

@@ -1,424 +0,0 @@
-/**
- * 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

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