browser-commander 0.26.3 → 0.28.0

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/readiness.test.js

@@ -427,6 +427,27 @@ describe('readiness', () => {
       assert.strictEqual(result.ready, false);
     });
 
+    it('should preserve timer expiry while a fractional clock budget remains', async () => {
+      const clock = createFakeClock();
+      const deadline = createDeadline({ timeout: 20, now: clock.now });
+      // The timer and monotonic clock can disagree by a fraction of a
+      // millisecond. Freeze that disagreement to reproduce it every time.
+      clock.advance(19.4);
+      const result = await runReadinessChecks({
+        checks: [
+          { name: 'never', run: () => new Promise(() => {}) },
+          ok('unreached'),
+        ],
+        deadline,
+      });
+
+      assert.strictEqual(deadline.expired(), false);
+      assert.strictEqual(result.status, READINESS_STATUS.TIMED_OUT);
+      assert.strictEqual(result.ready, false);
+      assert.deepStrictEqual(result.checks.pending, ['unreached']);
+      assert.strictEqual(result.evidence[0].detail.reason, 'deadline reached');
+    });
+
     it('should report elapsed and total budget on the result', async () => {
       const clock = createFakeClock();
       const deadline = createDeadline({ timeout: 800, now: clock.now });

package/tests/unit/core/trigger-readiness.test.js

@@ -0,0 +1,39 @@
+import { EventEmitter } from 'node:events';
+import { it } from 'node:test';
+import assert from 'node:assert/strict';
+import { createPageTriggerManager } from '../../../src/core/page-trigger-manager.js';
+
+it('DOM-ready triggers start without network idle and skip overlapping runs', async () => {
+  const events = new EventEmitter();
+  let release;
+  let calls = 0;
+  const manager = createPageTriggerManager({
+    navigationManager: events,
+    log: { debug() {} },
+  });
+  manager.pageTrigger({
+    readyOn: 'domcontentloaded',
+    concurrency: 'skip',
+    condition: () => true,
+    action: async () => {
+      calls++;
+      await new Promise((resolve) => {
+        release = resolve;
+      });
+    },
+  });
+  const page = new EventEmitter();
+  page.url = () => 'https://example.com/form';
+  manager.initialize({ page });
+  page.emit('domcontentloaded');
+  await new Promise((resolve) => setImmediate(resolve));
+  assert.equal(calls, 1);
+  page.emit('domcontentloaded');
+  await new Promise((resolve) => setImmediate(resolve));
+  assert.equal(calls, 1);
+  release();
+  await manager.destroy();
+  assert.equal(page.listenerCount('domcontentloaded'), 0);
+  assert.equal(events.listenerCount('onPageReady'), 0);
+});
+import { setImmediate } from 'node:timers';

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/elements/visible-count.test.js

@@ -0,0 +1,24 @@
+import { it } from 'node:test';
+import assert from 'node:assert/strict';
+import { count } from '../../../src/elements/visibility.js';
+
+it('counts only visible matches when requested', async () => {
+  const locator = {
+    count: async () => 3,
+    evaluateAll: async (fn) =>
+      fn([
+        { getClientRects: () => [1], checkVisibility: () => true },
+        { getClientRects: () => [], checkVisibility: () => false },
+        { getClientRects: () => [1], checkVisibility: () => true },
+      ]),
+  };
+  assert.equal(
+    await count({
+      page: { locator: () => locator },
+      engine: 'playwright',
+      selector: 'div',
+      visible: true,
+    }),
+    2
+  );
+});

package/tests/unit/elements/wait-navigation.test.js

@@ -0,0 +1,26 @@
+import { it } from 'node:test';
+import assert from 'node:assert/strict';
+import { waitForLocatorOrElement } from '../../../src/elements/locators.js';
+import { waitForSelector } from '../../../src/elements/selectors.js';
+
+for (const wait of [waitForLocatorOrElement, waitForSelector]) {
+  it(`${wait.name} treats a timeout after navigation as interrupted`, async () => {
+    let url = 'https://example.test/form';
+    const locator = {
+      first() {
+        return this;
+      },
+      async waitFor() {
+        url = 'https://example.test/sent';
+        throw Object.assign(new Error('timeout'), { name: 'TimeoutError' });
+      },
+    };
+    const result = await wait({
+      page: { url: () => url, locator: () => locator },
+      engine: 'playwright',
+      selector: 'button',
+      throwOnNavigation: false,
+    });
+    assert.ok(result === null || result === false);
+  });
+}

package/tests/unit/interactions/navigation-timeout.test.js

@@ -0,0 +1,39 @@
+import { it } from 'node:test';
+import assert from 'node:assert/strict';
+import { clickButton } from '../../../src/interactions/click.js';
+
+for (const change of ['url', 'session', 'none']) {
+  it(`element timeout detects ${change} changes`, async () => {
+    let url = 'https://example.com/form';
+    let session = 1;
+    const error = Object.assign(new Error('waitFor: Timeout 5000ms exceeded'), {
+      name: 'TimeoutError',
+    });
+    const locator = {
+      first: () => locator,
+      waitFor: async () => {
+        if (change === 'url') {
+          url = 'https://example.com/done';
+        }
+        if (change === 'session') {
+          session++;
+        }
+        throw error;
+      },
+    };
+    const operation = clickButton({
+      page: { url: () => url, locator: () => locator },
+      engine: 'playwright',
+      navigationManager: { getSessionId: () => session },
+      selector: '#submit',
+    });
+    if (change === 'none') {
+      await assert.rejects(operation, error);
+    } else {
+      const result = await operation;
+      assert.equal(result.status, 'interrupted');
+      assert.equal(result.navigated, true);
+      assert.equal(result.dispatched, false);
+    }
+  });
+}

package/tests/unit/scripts/ci-timeout-budgets.test.js

@@ -202,6 +202,7 @@ describe('CI execution budgets', () => {
       'parity.yml engine-suites Engine lifecycle suites',
       'parity.yml fixture-suites React fixture suites',
       'parity.yml parity Fingerprint parity suite',
+      'parity.yml parity Stable viewport displayed-pixel regression',
       'parity.yml parity WebDriver suite',
       'parity.yml snapshots Python headful real-browser launches',
       'parity.yml snapshots Python native snapshot launches',

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

@@ -232,6 +232,22 @@ describe('trace bundle writer (issue #87)', () => {
     assert.strictEqual(manifest.outcome, TRACE_OUTCOME.COMPLETE);
   });
 
+  it('retains every periodic drain in the same checkpoint interval', async () => {
+    const bundle = await open();
+    await bundle.writeMutations(1, [{ records: ['first'] }]);
+    await bundle.writeMutations(1, [{ records: ['second'] }]);
+    const lines = (
+      await fs.readFile(path.join(bundle.root, 'mutations/0001.ndjson'), 'utf8')
+    )
+      .trim()
+      .split('\n')
+      .map(JSON.parse);
+    assert.deepStrictEqual(lines, [
+      { records: ['first'] },
+      { records: ['second'] },
+    ]);
+  });
+
   it('should record a dropped member even under a tiny resource limit', async () => {
     // The record of a gap must not be the next thing that falls through it.
     const bundle = await open({ limits: { maxResourceBytes: 16 } });

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 () => {

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

@@ -0,0 +1,97 @@
+import { it } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { startTrace } from '../../../src/traces/recorder.js';
+import { UnsupportedCaptureError } from '../../../src/capture/errors.js';
+import {
+  createFakeCommander,
+  createFakePage,
+} from '../../helpers/trace-fixtures.js';
+
+it('records filtered network metadata and bounded redacted bodies in HAR', async () => {
+  const output = await fs.mkdtemp(path.join(os.tmpdir(), 'commander-network-'));
+  const page = createFakePage();
+  try {
+    const trace = await startTrace({
+      commander: createFakeCommander(page),
+      output,
+      initialCheckpoint: false,
+      network: {
+        resourceTypes: ['fetch'],
+        bodies: true,
+        maxBodyBytes: 4,
+        har: true,
+      },
+    });
+    const request = {
+      url: () => 'https://example.test/api',
+      method: () => 'GET',
+      resourceType: () => 'fetch',
+      headers: () => ({
+        authorization: 'secret',
+        cookie: 'session',
+        accept: 'text/plain',
+      }),
+      timing: () => ({ startTime: Date.now(), responseEnd: 10 }),
+    };
+    page.emit('request', request);
+    page.emit('response', {
+      request: () => request,
+      url: request.url,
+      status: () => 200,
+      headers: () => ({ 'set-cookie': 'secret', 'content-type': 'text/plain' }),
+      body: async () => Buffer.from('abcdef'),
+    });
+    await trace.stop();
+    const events = await fs.readFile(
+      path.join(output, 'events.ndjson'),
+      'utf8'
+    );
+    assert.match(events, /network.response/);
+    assert.doesNotMatch(events, /secret|session/);
+    const har = JSON.parse(
+      await fs.readFile(path.join(output, 'network.har'), 'utf8')
+    );
+    assert.equal(har.log.entries.length, 1);
+    assert.equal(har.log.entries[0].response.content.text, 'YWJjZA==');
+    assert.equal(har.log.entries[0].response.content._truncated, true);
+  } finally {
+    await fs.rm(output, { recursive: true, force: true });
+  }
+});
+
+it('rejected video startup removes every installed observer', async () => {
+  const output = await fs.mkdtemp(path.join(os.tmpdir(), 'commander-start-'));
+  const page = createFakePage();
+  const listeners = new Set();
+  const evaluate = page.evaluate.bind(page);
+  page.evaluate = (fn, argument) =>
+    argument === 'mov' ? Promise.resolve(false) : evaluate(fn, argument);
+  const on = page.on.bind(page);
+  const off = page.off.bind(page);
+  page.on = (event, listener) => {
+    listeners.add(listener);
+    return on(event, listener);
+  };
+  page.off = (event, listener) => {
+    listeners.delete(listener);
+    return off(event, listener);
+  };
+  try {
+    await assert.rejects(
+      startTrace({
+        commander: createFakeCommander(page),
+        output,
+        links: { output: path.join(output, 'trace.lino') },
+        video: { format: 'mov' },
+        network: true,
+      }),
+      UnsupportedCaptureError
+    );
+    assert.equal(listeners.size, 0);
+  } finally {
+    await fs.rm(output, { recursive: true, force: true });
+  }
+});