browser-commander 0.26.3 → 0.27.0

package/tests/unit/core/navigation-budget.test.js

@@ -0,0 +1,120 @@
+// feature-parity: navigation.budget@native-typed
+import { it } from 'node:test';
+import assert from 'node:assert/strict';
+import { createNavigationManager } from '../../../src/core/navigation-manager.js';
+import { goto } from '../../../src/browser/navigation.js';
+import { createNetworkTracker } from '../../../src/core/network-tracker.js';
+import {
+  createMockPlaywrightPage,
+  createMockLogger,
+} from '../../helpers/mocks.js';
+
+const delay = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const noWait = {
+  waitForStableUrlBefore: false,
+  waitForStableUrlAfter: false,
+  waitForNetworkIdle: false,
+  verify: false,
+};
+
+it('managed goto honors every no-wait option and keeps tracking', async () => {
+  const page = createMockPlaywrightPage();
+  let idleCalls = 0;
+  const manager = createNavigationManager({
+    page,
+    engine: 'playwright',
+    log: createMockLogger(),
+    networkTracker: {
+      reset() {},
+      waitForNetworkIdle: async () => {
+        idleCalls++;
+        await delay(80);
+        return true;
+      },
+    },
+  });
+  const started = performance.now();
+  const result = await goto({
+    page,
+    navigationManager: manager,
+    url: 'data:text/html,<h1>fixture</h1>',
+    timeout: 50,
+    ...noWait,
+  });
+  assert.equal(result.navigated, true);
+  assert.equal(idleCalls, 0);
+  assert.ok(performance.now() - started < 70);
+  assert.equal(manager.getSessionId(), 1);
+});
+
+it('engine navigation and stalled readiness share a single budget', async () => {
+  const page = createMockPlaywrightPage();
+  page.goto = async () => delay(30);
+  const manager = createNavigationManager({
+    page,
+    engine: 'playwright',
+    log: createMockLogger(),
+  });
+  const started = performance.now();
+  const result = await goto({
+    page,
+    navigationManager: manager,
+    url: 'data:text/html,fixture',
+    timeout: 60,
+    ...noWait,
+    checks: [{ name: 'stall', run: async () => new Promise(() => {}) }],
+  });
+  assert.equal(result.status, 'timed_out');
+  assert.ok(performance.now() - started < 100);
+  assert.equal(manager.isNavigating(), false);
+});
+
+it('caller abort promptly interrupts and unregisters its listener', async () => {
+  const page = createMockPlaywrightPage();
+  page.goto = async () => delay(180);
+  const manager = createNavigationManager({
+    page,
+    engine: 'playwright',
+    log: createMockLogger(),
+  });
+  const controller = new AbortController();
+  let listeners = 0;
+  const add = controller.signal.addEventListener.bind(controller.signal);
+  const remove = controller.signal.removeEventListener.bind(controller.signal);
+  controller.signal.addEventListener = (...args) => {
+    listeners++;
+    return add(...args);
+  };
+  controller.signal.removeEventListener = (...args) => {
+    listeners--;
+    return remove(...args);
+  };
+  const pending = goto({
+    page,
+    navigationManager: manager,
+    url: 'data:text/html,fixture',
+    timeout: 1000,
+    signal: controller.signal,
+    ...noWait,
+  });
+  setTimeout(() => controller.abort(), 20);
+  const result = await pending;
+  assert.equal(result.status, 'interrupted');
+  assert.equal(listeners, 0);
+  assert.equal(manager.isNavigating(), false);
+});
+
+it('an idle network wait respects a shorter timeout than its quiet period', async () => {
+  const page = createMockPlaywrightPage();
+  const tracker = createNetworkTracker({
+    page,
+    engine: 'playwright',
+    log: createMockLogger(),
+  });
+  const started = performance.now();
+  assert.equal(
+    await tracker.waitForNetworkIdle({ timeout: 30, idleTime: 100 }),
+    false
+  );
+  assert.ok(performance.now() - started < 80);
+});

package/tests/unit/core/navigation-manager.test.js

@@ -59,18 +59,40 @@ describe('navigation manager', () => {
       assert.strictEqual(loaded, true);
       assert.strictEqual(manager.getSessionId(), 1);
       assert.strictEqual(manager.isNavigating(), false);
+      const contentTimeout = calls.find(([name]) => name === 'setContent')[2]
+        .timeout;
+      assert.ok(contentTimeout > 0 && contentTimeout <= 5000);
       assert.deepStrictEqual(calls, [
         ['cleanup'],
         ['navigationStart'],
         [
           'setContent',
           '<h1>Hi</h1>',
-          { waitUntil: 'networkidle', timeout: 5000 },
+          { waitUntil: 'networkidle', timeout: contentTimeout },
         ],
         ['pageReady'],
       ]);
     });
 
+    it('bounds stalled content replacement and clears navigation state', async () => {
+      const page = createMockPlaywrightPage();
+      page.setContent = async () =>
+        new Promise((resolve) => setTimeout(resolve, 150));
+      const manager = createNavigationManager({
+        page,
+        engine: 'playwright',
+        log: createMockLogger(),
+      });
+      const start = performance.now();
+      assert.equal(
+        await manager.setContent({ html: '<h1>Bounded</h1>', timeout: 40 }),
+        false
+      );
+      assert.ok(performance.now() - start < 120);
+      assert.equal(manager.isNavigating(), false);
+      await new Promise((resolve) => setTimeout(resolve, 160));
+    });
+
     it('should require html while accepting an empty string', async () => {
       const page = createMockPlaywrightPage();
       const log = createMockLogger();

package/tests/unit/core/webdriver-page.test.js

@@ -256,6 +256,39 @@ describe('WebDriverPage', () => {
     );
   });
 
+  it('supplies BiDi cookie domains from explicit scope, URL or current page', async () => {
+    const { page, bidi } = bidiPage({
+      driverOptions: { url: 'https://current.example.test/path' },
+    });
+    await page.syncUrl();
+    await page.setCookie(
+      { name: 'current', value: 'artificial' },
+      {
+        name: 'url',
+        value: 'artificial',
+        url: 'https://url.example.test/path',
+      },
+      { name: 'domain', value: 'artificial', domain: '.explicit.example.test' }
+    );
+    const cookies = bidi.sent
+      .filter(({ method }) => method === 'storage.setCookie')
+      .map(({ params }) => params.cookie);
+    assert.deepEqual(
+      cookies.map(({ domain }) => domain),
+      ['current.example.test', 'url.example.test', '.explicit.example.test']
+    );
+    assert.ok(cookies.every((cookie) => !('url' in cookie)));
+    assert.ok(cookies.every((cookie) => !('expiry' in cookie)));
+    assert.equal(cookies[1].secure, true);
+    await page.setCookie({
+      name: 'http',
+      value: 'artificial',
+      url: 'http://url.example.test',
+      secure: false,
+    });
+    assert.equal(bidi.sent.at(-1).params.cookie.secure, false);
+  });
+
   it('adds and removes preload scripts over BiDi', async () => {
     const { page, bidi } = bidiPage({
       responses: { 'script.addPreloadScript': { script: 'preload-1' } },

package/tests/unit/elements/reusable-helpers.test.js

@@ -0,0 +1,83 @@
+import { it } from 'node:test';
+import assert from 'node:assert/strict';
+import * as api from '../../../src/index.js';
+import {
+  createMockPlaywrightPage,
+  createMockLogger,
+} from '../../helpers/mocks.js';
+
+it('finds ordered fallback selectors and supports alternate toggle texts', async () => {
+  const commander = api.makeBrowserCommander({
+    page: createMockPlaywrightPage({
+      elements: {
+        '#absent': { count: 0 },
+        '#present': { count: 1, visible: true },
+      },
+    }),
+    engine: 'playwright',
+    log: createMockLogger(),
+    enableNavigationManager: false,
+  });
+  assert.equal(
+    await commander.findFirst({
+      selectors: ['#absent', '#present'],
+      visible: true,
+    }),
+    '#present'
+  );
+  const found = await api.findToggleButton({
+    texts: ['one', 'two'],
+    elementTypes: ['button'],
+    count: async ({ selector }) => (selector === 'two' ? 1 : 0),
+    findByText: async ({ text }) => text,
+  });
+  assert.equal(found, 'two');
+  commander.destroy();
+});
+
+it('navigation subscriptions return idempotent unregister functions', () => {
+  const commander = api.makeBrowserCommander({
+    page: createMockPlaywrightPage(),
+    engine: 'playwright',
+  });
+  for (const event of [
+    'onUrlChange',
+    'onNavigationStart',
+    'onNavigationComplete',
+    'onPageReady',
+  ]) {
+    const unregister = commander[event](() => {});
+    assert.equal(typeof unregister, 'function');
+    unregister();
+    unregister();
+  }
+  commander.destroy();
+});
+
+it('exposes reusable text, checkbox, flag and cookie helpers', () => {
+  for (const name of [
+    'hasText',
+    'isChecked',
+    'check',
+    'readFlag',
+    'uninstallClickListener',
+    'setCookies',
+    'clearCookies',
+  ]) {
+    assert.equal(typeof api[name], 'function', name);
+  }
+});
+
+it('unsubscribe retains a second registration of the same callback', async () => {
+  const { subscribeCallbacks } =
+    await import('../../../src/core/subscriptions.js');
+  const callbacks = [],
+    callback = () => {};
+  const first = subscribeCallbacks(callbacks, callback);
+  const second = subscribeCallbacks(callbacks, callback);
+  first();
+  first();
+  assert.deepEqual(callbacks, [callback]);
+  second();
+  assert.deepEqual(callbacks, []);
+});

package/tests/unit/traces/links.test.js

@@ -544,8 +544,8 @@ describe('trace links export (issue #94)', () => {
     // The notation's formatter and parser decide whether an export can be read
     // back, so the range this package depends on and the version the tests
     // proved are the same range.
-    assert.strictEqual(manifest.dependencies['links-notation'], '^0.22.0');
-    assert.match(installed.version, /^0\.22\./);
+    assert.strictEqual(manifest.dependencies['links-notation'], '^0.23.0');
+    assert.match(installed.version, /^0\.23\./);
   });
 
   it('should export a bundle named by path as readily as an open one', async () => {