@web-auto/webauto 0.1.1 → 0.1.2

package/modules/operations/tests/viewport-filter.test.ts

@@ -1,161 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { parseHTML } from 'linkedom';
-
-import { createViewportFilter } from '../src/utils/visibility.js';
-
-function installDom(html: string, viewport: { width: number; height: number } = { width: 800, height: 600 }) {
-  const { window, document } = parseHTML(html);
-
-  (globalThis as any).window = window;
-  (globalThis as any).document = document;
-  (globalThis as any).Element = window.Element;
-  (globalThis as any).HTMLElement = window.HTMLElement;
-
-  Object.defineProperty(window, 'innerWidth', { value: viewport.width, configurable: true });
-  Object.defineProperty(window, 'innerHeight', { value: viewport.height, configurable: true });
-
-  if (typeof (document as any).elementFromPoint !== 'function') {
-    (document as any).elementFromPoint = (): Element | null => null;
-  }
-
-  return { window, document };
-}
-
-function setRect(el: Element, rect: { left: number; top: number; right: number; bottom: number }) {
-  const width = rect.right - rect.left;
-  const height = rect.bottom - rect.top;
-  (el as any).getBoundingClientRect = () => ({
-    ...rect,
-    x: rect.left,
-    y: rect.top,
-    width,
-    height,
-    toJSON() {
-      return this;
-    },
-  });
-}
-
-test('fully visible element passes fullyVisible check', async () => {
-  const { document } = installDom(`<div id="a">A</div>`);
-
-  // Fully inside viewport
-  setRect(document.getElementById('a')!, { left: 10, top: 10, right: 100, bottom: 100 });
-
-  const filter = createViewportFilter();
-  const result = filter({
-    selector: '#a',
-    index: 0,
-    visibleOnly: false,
-    fullyVisible: true,
-    anchor: null,
-  });
-
-  assert.equal(result.fullyVisible, true);
-  assert.equal(result.partiallyVisible, true);
-  assert.notEqual(result.clickPoint, null);
-});
-
-test('partially visible element fails fullyVisible but passes partiallyVisible', async () => {
-  const { document } = installDom(`<div id="b">B</div>`);
-
-  // Partially outside bottom
-  setRect(document.getElementById('b')!, { left: 10, top: 500, right: 100, bottom: 700 });
-
-  const filter = createViewportFilter();
-  const result = filter({
-    selector: '#b',
-    index: 0,
-    visibleOnly: false,
-    fullyVisible: true,
-    anchor: null,
-  });
-
-  assert.equal(result.fullyVisible, false);
-  assert.equal(result.partiallyVisible, true);
-  assert.equal(result.clickPoint, null);
-});
-
-test('off-screen element fails both checks', async () => {
-  const { document } = installDom(`<div id="c">C</div>`);
-
-  // Completely outside viewport
-  setRect(document.getElementById('c')!, { left: 1000, top: 2000, right: 1100, bottom: 2100 });
-
-  const filter = createViewportFilter();
-  const result = filter({
-    selector: '#c',
-    index: 0,
-    visibleOnly: false,
-    fullyVisible: true,
-    anchor: null,
-  });
-
-  assert.equal(result.fullyVisible, false);
-  assert.equal(result.partiallyVisible, false);
-  assert.equal(result.element, null);
-  assert.equal(result.clickPoint, null);
-});
-
-test('anchor verification passes when hit matches element', async () => {
-  const { document } = installDom(`<div id="d">D</div>`);
-
-  setRect(document.getElementById('d')!, { left: 10, top: 10, right: 100, bottom: 100 });
-
-  (document as any).elementFromPoint = () => document.getElementById('d');
-
-  const filter = createViewportFilter();
-  const result = filter({
-    selector: '#d',
-    index: 0,
-    visibleOnly: false,
-    fullyVisible: true,
-    anchor: { x: 50, y: 50 },
-  });
-
-  assert.equal(result.anchorMatch, true);
-  assert.notEqual(result.clickPoint, null);
-});
-
-test('anchor verification fails when hit does not match element', async () => {
-  const { document } = installDom(`<div id="e">E</div><div id="f">F</div>`);
-
-  setRect(document.getElementById('e')!, { left: 10, top: 10, right: 100, bottom: 100 });
-  setRect(document.getElementById('f')!, { left: 200, top: 200, right: 300, bottom: 300 });
-
-  // elementFromPoint returns f instead of e
-  (document as any).elementFromPoint = () => document.getElementById('f');
-
-  const filter = createViewportFilter();
-  const result = filter({
-    selector: '#e',
-    index: 0,
-    visibleOnly: false,
-    fullyVisible: true,
-    anchor: { x: 50, y: 50 },
-  });
-
-  assert.equal(result.anchorMatch, false);
-  assert.equal(result.clickPoint?.x, 55);
-  assert.equal(result.clickPoint?.y, 55);
-});
-
-test('zero size element fails visibility check', async () => {
-  const { document } = installDom(`<div id="g">G</div>`);
-
-  // Zero size
-  setRect(document.getElementById('g')!, { left: 10, top: 10, right: 10, bottom: 10 });
-
-  const filter = createViewportFilter();
-  const result = filter({
-    selector: '#g',
-    index: 0,
-    visibleOnly: false,
-    fullyVisible: true,
-    anchor: null,
-  });
-
-  assert.equal(result.fullyVisible, false);
-  assert.equal(result.partiallyVisible, false);
-});

package/modules/operations/tests/visible-only.test.ts

@@ -1,250 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { parseHTML } from 'linkedom';
-
-import { highlightOperation } from '../src/operations/highlight.js';
-import { extractOperation } from '../src/operations/extract.js';
-import { clickOperation } from '../src/operations/click.js';
-import { scrollOperation } from '../src/operations/scroll.js';
-
-function installDom(html: string) {
-  const { window, document } = parseHTML(html);
-
-  (globalThis as any).window = window;
-  (globalThis as any).document = document;
-  (globalThis as any).Element = window.Element;
-  (globalThis as any).HTMLElement = window.HTMLElement;
-  (globalThis as any).HTMLAnchorElement = window.HTMLAnchorElement;
-  (globalThis as any).HTMLImageElement = window.HTMLImageElement;
-
-  Object.defineProperty(window, 'innerWidth', { value: 800, configurable: true });
-  Object.defineProperty(window, 'innerHeight', { value: 600, configurable: true });
-
-  if (typeof (document as any).elementFromPoint !== 'function') {
-    (document as any).elementFromPoint = (): Element | null => null;
-  }
-
-  return { window, document };
-}
-
-function setRect(el: Element, rect: { left: number; top: number; right: number; bottom: number }) {
-  const width = rect.right - rect.left;
-  const height = rect.bottom - rect.top;
-  (el as any).getBoundingClientRect = () => ({
-    ...rect,
-    x: rect.left,
-    y: rect.top,
-    width,
-    height,
-  });
-}
-
-test('highlight supports visibleOnly filtering (overlay mode)', async () => {
-  const { window, document } = installDom(`
-    <div class="x" id="a">A</div>
-    <div class="x" id="b">B</div>
-  `);
-
-  setRect(document.getElementById('a')!, { left: 10, top: 10, right: 110, bottom: 60 });
-  setRect(document.getElementById('b')!, { left: 10, top: 2000, right: 110, bottom: 2050 });
-
-  let highlightCount = 0;
-  (window as any).__webautoRuntime = {
-    highlight: {
-      highlightElements: (els: any[]) => {
-        highlightCount = Array.isArray(els) ? els.length : 0;
-      },
-    },
-  };
-
-  const res = await highlightOperation.run(
-    {
-      page: {
-        evaluate: async (fn: any, arg: any) => fn(arg),
-      },
-    },
-    { selector: '.x', visibleOnly: true, channel: 'test', duration: 1000 },
-  );
-
-  assert.equal(res.success, true);
-  assert.equal(res.mode, 'overlay');
-  assert.equal(res.count, 1);
-  assert.equal(highlightCount, 1);
-});
-
-test('extract supports visibleOnly filtering', async () => {
-  const { document } = installDom(`
-    <div class="item" id="a">A</div>
-    <div class="item" id="b">B</div>
-  `);
-
-  setRect(document.getElementById('a')!, { left: 10, top: 10, right: 110, bottom: 60 });
-  setRect(document.getElementById('b')!, { left: 10, top: 2000, right: 110, bottom: 2050 });
-
-  const res = await extractOperation.run(
-    {
-      page: {
-        evaluate: async (fn: any, arg: any) => fn(arg),
-      },
-    },
-    { selector: '.item', include_text: true, max_items: 10, visibleOnly: true },
-  );
-
-  assert.equal(res.success, true);
-  assert.equal(res.count, 1);
-  assert.equal(res.extracted?.[0]?.text, 'A');
-});
-
-test('click supports visibleOnly filtering and uses system mouse', async () => {
-  const { document } = installDom(`
-    <div class="btn" id="a"><span class="inner">A</span></div>
-    <div class="btn" id="b"><span class="inner">B</span></div>
-  `);
-
-  const a = document.getElementById('a')!;
-  const b = document.getElementById('b')!;
-  const aInner = a.querySelector('.inner') as Element;
-  const bInner = b.querySelector('.inner') as Element;
-  setRect(a, { left: 100, top: 100, right: 300, bottom: 200 });
-  setRect(aInner, { left: 100, top: 100, right: 300, bottom: 200 });
-  setRect(b, { left: 100, top: 2000, right: 300, bottom: 2100 });
-  setRect(bInner, { left: 100, top: 2000, right: 300, bottom: 2100 });
-
-  // Make elementFromPoint always hit within the visible element.
-  (document as any).elementFromPoint = () => aInner;
-
-  let clicked: { x: number; y: number } | null = null;
-  const res = await clickOperation.run(
-    {
-      page: {
-        evaluate: async (fn: any, arg: any) => fn(arg),
-      },
-      systemInput: {
-        mouseClick: async (x: number, y: number) => {
-          clicked = { x, y };
-          return { success: true };
-        },
-        mouseMove: async () => ({ success: true }),
-      },
-    },
-    { selector: '.btn', index: 0, target: '.inner', useSystemMouse: true, visibleOnly: true },
-  );
-
-  assert.equal(res.success, true);
-  assert.deepEqual(clicked, { x: 200, y: 150 });
-});
-
-
-
-test('click supports protocol mode without system mouse', async () => {
-  const { document } = installDom(`
-    <div class="btn" id="a"><span class="inner">A</span></div>
-  `);
-
-  const a = document.getElementById('a')!;
-  const aInner = a.querySelector('.inner') as Element;
-  setRect(a, { left: 100, top: 100, right: 300, bottom: 200 });
-  setRect(aInner, { left: 100, top: 100, right: 300, bottom: 200 });
-  (document as any).elementFromPoint = () => aInner;
-
-  let clicked: { x: number; y: number } | null = null;
-  const res = await clickOperation.run(
-    {
-      page: {
-        evaluate: async (fn: any, arg: any) => fn(arg),
-        mouse: {
-          click: async (x: number, y: number) => {
-            clicked = { x, y };
-          },
-        },
-      } as any,
-    },
-    { selector: '.btn', index: 0, target: '.inner', useSystemMouse: false, visibleOnly: true },
-  );
-
-  assert.equal(res.success, true);
-  assert.equal(res.inputMode, 'protocol');
-  assert.deepEqual(clicked, { x: 200, y: 150 });
-});
-
-test('scroll moves mouse into selector before wheel', async () => {
-  const { document } = installDom(`
-    <div class="scroller" id="s"><div id="child"></div></div>
-  `);
-
-  const s = document.getElementById('s')!;
-  const child = document.getElementById('child')!;
-  setRect(s, { left: 100, top: 100, right: 500, bottom: 500 });
-  setRect(child, { left: 120, top: 120, right: 140, bottom: 140 });
-
-  (document as any).elementFromPoint = () => child;
-
-  let moved: { x: number; y: number } | null = null;
-  let wheel: { dx: number; dy: number } | null = null;
-
-  const res = await scrollOperation.run(
-    {
-      page: {
-        evaluate: async (fn: any, arg: any) => fn(arg),
-        keyboard: undefined,
-      },
-      systemInput: {
-        mouseMove: async (x: number, y: number) => {
-          moved = { x, y };
-          return { success: true };
-        },
-        mouseWheel: async (dx: number, dy: number) => {
-          wheel = { dx, dy };
-          return { success: true };
-        },
-        mouseClick: async () => ({ success: true }),
-      },
-    },
-    { selector: '.scroller', direction: 'down', distance: 600 },
-  );
-
-  assert.equal(res.success, true);
-  // We should move near the top-middle (top + pad=24), not the center.
-  assert.deepEqual(moved, { x: 300, y: 124 });
-  assert.deepEqual(wheel, { dx: 0, dy: 600 });
-});
-
-
-test('scroll supports protocol mode without system wheel', async () => {
-  const { document } = installDom(`
-    <div class="scroller" id="s"><div id="child"></div></div>
-  `);
-
-  const s = document.getElementById('s')!;
-  const child = document.getElementById('child')!;
-  setRect(s, { left: 100, top: 100, right: 500, bottom: 500 });
-  setRect(child, { left: 120, top: 120, right: 140, bottom: 140 });
-
-  (document as any).elementFromPoint = () => child;
-
-  let moved: { x: number; y: number } | null = null;
-  let wheel: { dx: number; dy: number } | null = null;
-
-  const res = await scrollOperation.run(
-    {
-      page: {
-        evaluate: async (fn: any, arg: any) => fn(arg),
-        keyboard: undefined,
-        mouse: {
-          move: async (x: number, y: number) => {
-            moved = { x, y };
-          },
-          wheel: async (dx: number, dy: number) => {
-            wheel = { dx, dy };
-          },
-        },
-      } as any,
-    },
-    { selector: '.scroller', direction: 'down', distance: 600, useSystemMouse: false },
-  );
-
-  assert.equal(res.success, true);
-  assert.equal(res.inputMode, 'protocol');
-  assert.deepEqual(moved, { x: 300, y: 124 });
-  assert.deepEqual(wheel, { dx: 0, dy: 600 });
-});

package/modules/session-manager/tests/session-manager.test.ts

@@ -1,23 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import { run as runCli } from '../src/cli.js';
-
-test('session-manager cli create/list/delete works in test mode', async () => {
-  process.env.SESSION_MANAGER_TEST_MODE = '1';
-
-  const create = await runCli(['create', '--profile', 'demo', '--url', 'https://example.com']);
-  assert.equal(create.success, true);
-  assert.equal(create.data.sessionId, 'demo');
-
-  const list = await runCli(['list']);
-  assert.equal(list.success, true);
-  assert.equal(list.data.sessions.length, 1);
-
-  const del = await runCli(['delete', '--profile', 'demo']);
-  assert.equal(del.success, true);
-
-  const listAfter = await runCli(['list']);
-  assert.equal(listAfter.data.sessions.length, 0);
-
-  delete process.env.SESSION_MANAGER_TEST_MODE;
-});

package/modules/state/src/atomic-json.test.ts

@@ -1,30 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import os from 'node:os';
-import path from 'node:path';
-import { promises as fs } from 'node:fs';
-
-import { atomicWriteJson, readJsonMaybe } from './atomic-json.js';
-
-test('readJsonMaybe returns null when file missing', async () => {
-  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'webauto-atomic-'));
-  const p = path.join(root, 'missing.json');
-  const v = await readJsonMaybe(p);
-  assert.equal(v, null);
-});
-
-test('atomicWriteJson writes json and readJsonMaybe reads it back', async () => {
-  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'webauto-atomic-'));
-  const p = path.join(root, 'state.json');
-  await atomicWriteJson(p, { ok: true, n: 1 });
-  const v = await readJsonMaybe<any>(p);
-  assert.deepEqual(v, { ok: true, n: 1 });
-});
-
-test('readJsonMaybe throws on invalid json', async () => {
-  const root = await fs.mkdtemp(path.join(os.tmpdir(), 'webauto-atomic-'));
-  const p = path.join(root, 'bad.json');
-  await fs.writeFile(p, '{bad json', 'utf8');
-  await assert.rejects(async () => readJsonMaybe(p));
-});
-

package/modules/state/src/paths.test.ts

@@ -1,59 +0,0 @@
-import test from 'node:test';
-import assert from 'node:assert/strict';
-import path from 'node:path';
-
-import { resolveDownloadRoot, resolveHomeDir, resolvePlatformEnvKeywordDir } from './paths.js';
-
-test('resolveHomeDir prefers platform env var when provided', () => {
-  const prevHome = process.env.HOME;
-  const prevUser = process.env.USERPROFILE;
-  try {
-    process.env.HOME = '/tmp/homeA';
-    process.env.USERPROFILE = 'C:\\Users\\HomeB';
-    const home = resolveHomeDir();
-    if (process.platform === 'win32') {
-      assert.equal(home, 'C:\\Users\\HomeB');
-    } else {
-      assert.equal(home, '/tmp/homeA');
-    }
-  } finally {
-    if (prevHome == null) delete process.env.HOME;
-    else process.env.HOME = prevHome;
-    if (prevUser == null) delete process.env.USERPROFILE;
-    else process.env.USERPROFILE = prevUser;
-  }
-});
-
-test('resolveDownloadRoot honors WEBAUTO_DOWNLOAD_ROOT override', () => {
-  const prev = process.env.WEBAUTO_DOWNLOAD_ROOT;
-  try {
-    process.env.WEBAUTO_DOWNLOAD_ROOT = '/tmp/webauto-download';
-    assert.equal(resolveDownloadRoot(), '/tmp/webauto-download');
-  } finally {
-    if (prev == null) delete process.env.WEBAUTO_DOWNLOAD_ROOT;
-    else process.env.WEBAUTO_DOWNLOAD_ROOT = prev;
-  }
-});
-
-test('resolvePlatformEnvKeywordDir joins platform/env/keyword under downloadRoot', () => {
-  const p = resolvePlatformEnvKeywordDir({
-    downloadRoot: '/tmp/dl',
-    platform: 'xiaohongshu',
-    env: 'debug',
-    keyword: '工作服',
-  });
-  assert.equal(p, path.join('/tmp/dl', 'xiaohongshu', 'debug', '工作服'));
-});
-
-test('resolvePlatformEnvKeywordDir validates required fields', () => {
-  assert.throws(() =>
-    resolvePlatformEnvKeywordDir({ downloadRoot: '/tmp/dl', platform: '', env: 'debug', keyword: 'k' }),
-  );
-  assert.throws(() =>
-    resolvePlatformEnvKeywordDir({ downloadRoot: '/tmp/dl', platform: 'x', env: '', keyword: 'k' }),
-  );
-  assert.throws(() =>
-    resolvePlatformEnvKeywordDir({ downloadRoot: '/tmp/dl', platform: 'x', env: 'e', keyword: '' }),
-  );
-});
-