cdp-skill 1.0.7 → 1.0.14

package/src/tests/ExecuteInteraction.test.js

@@ -0,0 +1,319 @@
+import { describe, it, mock, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert';
+
+import {
+  executeClick,
+  executeHover,
+  executeDrag,
+  captureHoverResult
+} from '../runner/execute-interaction.js';
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+function createMockElementLocator(opts = {}) {
+  return {
+    session: {
+      send: mock.fn((method, params) => {
+        if (method === 'Runtime.evaluate') {
+          if (opts.evaluateException) {
+            return Promise.resolve({
+              result: { value: undefined },
+              exceptionDetails: {
+                text: opts.evaluateException
+              }
+            });
+          }
+          if (opts.captureElements) {
+            return Promise.resolve({
+              result: {
+                value: opts.captureElements
+              }
+            });
+          }
+          if (opts.elementBox) {
+            return Promise.resolve({
+              result: {
+                value: opts.elementBox
+              }
+            });
+          }
+          if (opts.elementNotFound) {
+            return Promise.resolve({
+              result: {
+                value: null
+              }
+            });
+          }
+          return Promise.resolve({
+            result: {
+              value: []
+            }
+          });
+        }
+        return Promise.resolve({});
+      })
+    },
+    findElement: mock.fn(() => {
+      if (opts.notFound) return Promise.resolve(null);
+      return Promise.resolve({ objectId: 'obj-123' });
+    })
+  };
+}
+
+function createMockInputEmulator() {
+  return {
+    click: mock.fn(() => Promise.resolve()),
+    hover: mock.fn(() => Promise.resolve()),
+    mouseDown: mock.fn(() => Promise.resolve()),
+    mouseMove: mock.fn(() => Promise.resolve()),
+    mouseUp: mock.fn(() => Promise.resolve())
+  };
+}
+
+function createMockAriaSnapshot(opts = {}) {
+  return {
+    getElementByRef: mock.fn((ref) => {
+      if (opts.refNotFound || ref === 'missing') {
+        return Promise.resolve(null);
+      }
+      if (opts.refStale) {
+        return Promise.resolve({
+          box: { x: 100, y: 100, width: 50, height: 30 },
+          stale: true
+        });
+      }
+      return Promise.resolve({
+        box: { x: 100, y: 100, width: 50, height: 30 },
+        isVisible: true,
+        stale: false
+      });
+    }),
+    findByText: mock.fn((text) => {
+      if (opts.textNotFound || text === 'Missing') {
+        return Promise.resolve(null);
+      }
+      return Promise.resolve({
+        box: { x: 200, y: 150, width: 100, height: 40 }
+      });
+    })
+  };
+}
+
+function createMockPageController(opts = {}) {
+  return {
+    session: {
+      send: mock.fn(() => Promise.resolve({}))
+    },
+    getFrameContext: mock.fn(() => opts.contextId || null)
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Tests: executeClick
+// ---------------------------------------------------------------------------
+
+describe('executeClick', () => {
+  afterEach(() => { mock.reset(); });
+
+  it('should delegate to ClickExecutor', async () => {
+    const locator = createMockElementLocator();
+    const emulator = createMockInputEmulator();
+    const snapshot = createMockAriaSnapshot();
+
+    // executeClick creates a ClickExecutor internally
+    // We can't easily mock the creation, but we can verify it doesn't throw
+    try {
+      await executeClick(locator, emulator, snapshot, { selector: '#button' });
+    } catch (e) {
+      // May fail due to mocking limitations, but verifies basic call structure
+      assert.ok(e.message.length > 0);
+    }
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Tests: executeHover
+// ---------------------------------------------------------------------------
+
+describe('executeHover', () => {
+  afterEach(() => { mock.reset(); });
+
+  it('should hover at coordinates', async () => {
+    const locator = createMockElementLocator();
+    const emulator = createMockInputEmulator();
+    const snapshot = createMockAriaSnapshot();
+
+    const result = await executeHover(locator, emulator, snapshot, {
+      x: 100,
+      y: 200
+    });
+
+    assert.strictEqual(result.hovered, true);
+    assert.strictEqual(emulator.hover.mock.calls.length, 1);
+  });
+
+  it('should hover by text', async () => {
+    const locator = createMockElementLocator();
+    const emulator = createMockInputEmulator();
+    const snapshot = createMockAriaSnapshot();
+
+    const result = await executeHover(locator, emulator, snapshot, {
+      text: 'Button Text'
+    });
+
+    assert.strictEqual(result.hovered, true);
+    assert.strictEqual(snapshot.findByText.mock.calls.length, 1);
+  });
+
+  it('should throw if text not found', async () => {
+    const locator = createMockElementLocator();
+    const emulator = createMockInputEmulator();
+    const snapshot = createMockAriaSnapshot({ textNotFound: true });
+
+    await assert.rejects(
+      executeHover(locator, emulator, snapshot, { text: 'Missing' }),
+      { message: /element not found/i }
+    );
+  });
+
+  it('should hover by ref', async () => {
+    const locator = createMockElementLocator();
+    const emulator = createMockInputEmulator();
+    const snapshot = createMockAriaSnapshot();
+
+    const result = await executeHover(locator, emulator, snapshot, {
+      ref: 's1e1'
+    });
+
+    assert.strictEqual(result.hovered, true);
+    assert.strictEqual(snapshot.getElementByRef.mock.calls.length, 1);
+  });
+
+  it('should throw if ref not found', async () => {
+    const locator = createMockElementLocator();
+    const emulator = createMockInputEmulator();
+    const snapshot = createMockAriaSnapshot({ refNotFound: true });
+
+    await assert.rejects(
+      executeHover(locator, emulator, snapshot, { ref: 'missing' }),
+      { message: /element not found/i }
+    );
+  });
+
+  it('should capture hover result when captureResult is true', async () => {
+    const locator = createMockElementLocator({
+      captureElements: [
+        { type: 'menu', items: ['Item 1', 'Item 2'] }
+      ]
+    });
+    const emulator = createMockInputEmulator();
+    const snapshot = createMockAriaSnapshot();
+
+    const result = await executeHover(locator, emulator, snapshot, {
+      x: 100,
+      y: 200,
+      captureResult: true
+    });
+
+    assert.strictEqual(result.hovered, true);
+    assert.ok(result.capturedResult);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Tests: captureHoverResult
+// ---------------------------------------------------------------------------
+
+describe('captureHoverResult', () => {
+  afterEach(() => { mock.reset(); });
+
+  it('should capture newly appeared elements', async () => {
+    const session = {
+      send: mock.fn(() => Promise.resolve({
+        result: {
+          value: [
+            { type: 'menu', items: ['New Item 1', 'New Item 2'] },
+            { type: 'tooltip', text: 'Tooltip text' }
+          ]
+        }
+      }))
+    };
+
+    const visibleBefore = [
+      JSON.stringify({ type: 'existing', text: 'Already visible' })
+    ];
+
+    const result = await captureHoverResult(session, visibleBefore);
+
+    assert.strictEqual(result.hovered, true);
+    assert.ok(result.capturedResult);
+    assert.strictEqual(result.capturedResult.visibleElements.length, 2);
+  });
+
+  it('should handle capture errors gracefully', async () => {
+    const session = {
+      send: mock.fn(() => Promise.reject(new Error('CDP error')))
+    };
+
+    const result = await captureHoverResult(session, []);
+
+    assert.strictEqual(result.hovered, true);
+    assert.strictEqual(result.capturedResult.visibleElements.length, 0);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// Tests: executeDrag
+// ---------------------------------------------------------------------------
+
+describe('executeDrag', () => {
+  afterEach(() => { mock.reset(); });
+
+  it('should throw if ref not found for source', async () => {
+    const locator = createMockElementLocator();
+    const emulator = createMockInputEmulator();
+    const pc = createMockPageController();
+    const snapshot = createMockAriaSnapshot({ refNotFound: true });
+
+    // Drag with ref in object format
+    await assert.rejects(
+      executeDrag(locator, emulator, pc, snapshot, {
+        source: { ref: 'missing' },
+        target: { x: 200, y: 200 }
+      }),
+      { message: /element not found/i }
+    );
+  });
+
+  it('should throw if ref is stale', async () => {
+    const locator = createMockElementLocator();
+    const emulator = createMockInputEmulator();
+    const pc = createMockPageController();
+    const snapshot = createMockAriaSnapshot({ refStale: true });
+
+    await assert.rejects(
+      executeDrag(locator, emulator, pc, snapshot, {
+        source: 's1e1',
+        target: { x: 200, y: 200 }
+      }),
+      { message: /no longer attached/i }
+    );
+  });
+
+  it('should throw if source element not found', async () => {
+    const locator = createMockElementLocator({ elementNotFound: true });
+    const emulator = createMockInputEmulator();
+    const pc = createMockPageController();
+    const snapshot = createMockAriaSnapshot();
+
+    await assert.rejects(
+      executeDrag(locator, emulator, pc, snapshot, {
+        source: '#missing',
+        target: { x: 200, y: 200 }
+      }),
+      { message: /element not found/i }
+    );
+  });
+});