browser-commander 0.28.0 → 0.30.0

package/tests/unit/traces/issue-162-user-actions.test.js

@@ -0,0 +1,181 @@
+import { it } from 'node:test';
+import assert from 'node:assert/strict';
+import vm from 'node:vm';
+import { installUserActionRecorderInPage } from '../../../src/traces/user-actions.js';
+import { observeCommanderActions } from '../../../src/traces/commander-actions.js';
+import { interactionTarget } from '../../../src/traces/observers.js';
+
+function documentFixture(options = {}) {
+  const listeners = new Map();
+  const window = {
+    CSS: { escape: (id) => id },
+    getComputedStyle: () => ({ visibility: 'visible' }),
+  };
+  window.top = window;
+  const root = { getElementById: () => null };
+  const target = {
+    nodeType: 1,
+    localName: options.tag ?? 'button',
+    id: 'delete',
+    type: 'text',
+    labels: [],
+    value: 'PRIVATE_TYPED_TEXT',
+    childNodes: [],
+    getRootNode: () => root,
+    getClientRects: () => [{}],
+    getAttribute: (name) => (name === 'aria-label' ? 'Delete position' : null),
+    closest: (selector) =>
+      selector === '[data-private]'
+        ? options.secret
+          ? target
+          : null
+        : selector === '#other'
+          ? null
+          : selector === target.localName || selector.includes('button')
+            ? target
+            : null,
+    querySelector: () => null,
+  };
+  target.childNodes.push({
+    nodeType: 3,
+    nodeValue: options.text ?? 'Delete',
+    parentElement: target,
+    getRootNode: () => root,
+  });
+  const context = vm.createContext({
+    window,
+    location: { href: 'https://example.test/' },
+    document: {
+      activeElement: target,
+      addEventListener: (name, listener) => listeners.set(name, listener),
+      removeEventListener: (name) => listeners.delete(name),
+    },
+  });
+  vm.runInContext(
+    `(${installUserActionRecorderInPage.toString()})(${JSON.stringify({
+      globalName: 'recorder',
+      binding: null,
+      maxQueued: 2,
+      redactSelectors: ['[data-private]'],
+      ignoreSelectors: [],
+      redacted: '[redacted]',
+    })})`,
+    context
+  );
+  const fire = (type, extras = {}) =>
+    listeners.get(type)?.({
+      type,
+      isTrusted: true,
+      target,
+      composedPath: () => [extras.target ?? target],
+      ...extras,
+    });
+  const evaluate = (fn, argument, element = null) => {
+    context.argument = argument;
+    context.element = element;
+    return vm.runInContext(
+      `(${fn.toString()})(...${element ? '[element, argument]' : '[argument]'})`,
+      context
+    );
+  };
+  return { window, target, listeners, fire, evaluate, state: window.recorder };
+}
+
+function observeActions(commander, evaluate, name) {
+  const recorded = [];
+  const detach = observeCommanderActions({
+    commander,
+    page: { evaluate },
+    names: [name],
+    targetOf: interactionTarget,
+    now: () => 0,
+    record: async (kind, event) => recorded.push({ kind, ...event }),
+  });
+  return { recorded, detach };
+}
+
+it('records only trusted actions and non-text keys, and stops listeners', () => {
+  const { fire, state, listeners } = documentFixture();
+  fire('click', { isTrusted: false });
+  fire('keydown', { key: 'a' });
+  fire('keydown', { key: 'Enter', isComposing: true });
+  assert.equal(state.queue.length, 0);
+  fire('click');
+  fire('keydown', { key: 'Escape' });
+  assert.equal(state.queue.length, 2);
+  assert.equal(state.queue[0].source, 'user');
+  assert.equal(state.queue[0].target.name, 'Delete position');
+  assert.equal(state.queue[1].key, 'Escape');
+  assert.doesNotMatch(JSON.stringify(state.queue), /PRIVATE_TYPED_TEXT/);
+  state.stop();
+  assert.equal(listeners.size, 0);
+});
+
+it('bounds the action queue and redacts private targets before delivery', () => {
+  const { fire, state } = documentFixture({
+    secret: true,
+    text: 'PRIVATE_TARGET',
+  });
+  for (let i = 0; i < 5; i += 1) {
+    fire('click');
+  }
+  assert.equal(state.queue.length, 2);
+  assert.equal(state.dropped, 3);
+  assert.doesNotMatch(JSON.stringify(state.queue), /PRIVATE_TARGET/);
+  assert.equal(state.queue[0].target.name, '[redacted]');
+});
+
+it('never describes typed textarea text and keeps unrelated manual actions during automation', () => {
+  const { fire, state, window } = documentFixture({
+    tag: 'textarea',
+    text: 'PRIVATE_TEXTAREA',
+  });
+  window.__browserCommanderActions__ = [
+    { selector: '#other', types: ['click'] },
+  ];
+  fire('click');
+  assert.equal(state.queue.length, 1);
+  assert.equal(state.queue[0].target.text, '');
+  assert.doesNotMatch(JSON.stringify(state.queue), /PRIVATE_TEXTAREA/);
+});
+
+it('attributes element-handle input to the commander and removes its marker', async () => {
+  const { fire, state, evaluate, target, window } = documentFixture();
+  const element = {
+    evaluate: (fn, argument) => evaluate(fn, argument, target),
+  };
+  const commander = { clickElement: async () => fire('click') };
+  const { recorded, detach } = observeActions(
+    commander,
+    evaluate,
+    'clickElement'
+  );
+  try {
+    await commander.clickElement({ locatorOrElement: element });
+    assert.equal(state.queue.length, 0);
+    assert.equal(recorded[0].source, 'commander');
+    assert.equal(window.__browserCommanderActions__.length, 0);
+  } finally {
+    detach();
+  }
+});
+
+it('attributes keyboard activation clicks to the commander without suppressing other controls', async () => {
+  const { fire, state, evaluate, target } = documentFixture();
+  target.contains = (node) => node === target;
+  const commander = {
+    pressKey: async () => {
+      fire('keydown', { key: 'Enter' });
+      fire('click', { detail: 0 });
+      fire('click', { target: { ...target, closest: () => null } });
+    },
+  };
+  const { recorded, detach } = observeActions(commander, evaluate, 'pressKey');
+  try {
+    await commander.pressKey({ key: 'Enter' });
+    assert.equal(state.queue.length, 1);
+    assert.equal(recorded[0].source, 'commander');
+  } finally {
+    detach();
+  }
+});

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

@@ -10,9 +10,15 @@ import {
   createFakePage,
 } from '../../helpers/trace-fixtures.js';
 
+async function networkFixture() {
+  return {
+    output: await fs.mkdtemp(path.join(os.tmpdir(), 'commander-network-')),
+    page: createFakePage(),
+  };
+}
+
 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();
+  const { output, page } = await networkFixture();
   try {
     const trace = await startTrace({
       commander: createFakeCommander(page),
@@ -55,7 +61,7 @@ it('records filtered network metadata and bounded redacted bodies in HAR', async
       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.text, 'abcd');
     assert.equal(har.log.entries[0].response.content._truncated, true);
   } finally {
     await fs.rm(output, { recursive: true, force: true });
@@ -95,3 +101,49 @@ it('rejected video startup removes every installed observer', async () => {
     await fs.rm(output, { recursive: true, force: true });
   }
 });
+
+it('omits binary bytes while preserving reported original size without buffering', async () => {
+  const { output, page } = await networkFixture();
+  try {
+    const trace = await startTrace({
+      commander: createFakeCommander(page),
+      output,
+      initialCheckpoint: false,
+      network: { bodies: true, har: true },
+    });
+    const request = {
+      url: () => 'https://example.test/binary',
+      method: () => 'GET',
+      resourceType: () => 'fetch',
+      headers: () => ({}),
+      sizes: async () => ({ responseBodySize: 1234 }),
+    };
+    page.emit('request', request);
+    page.emit('response', {
+      request: () => request,
+      status: () => 200,
+      headers: () => ({ 'content-type': 'application/octet-stream' }),
+      body: async () => {
+        assert.fail('binary body must not be buffered');
+      },
+    });
+    await trace.stop();
+    const events = (
+      await fs.readFile(path.join(output, 'events.ndjson'), 'utf8')
+    )
+      .trim()
+      .split('\n')
+      .map(JSON.parse);
+    assert.deepEqual(
+      events.find((event) => event.kind === 'network.response').body,
+      { size: 1234, omitted: 'binary' }
+    );
+    const har = JSON.parse(
+      await fs.readFile(path.join(output, 'network.har'), 'utf8')
+    );
+    assert.equal(har.log.entries[0].response.content.size, 1234);
+    assert.equal(har.log.entries[0].response.content.text, undefined);
+  } finally {
+    await fs.rm(output, { recursive: true, force: true });
+  }
+});

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

@@ -45,6 +45,9 @@ describe('trace recorder (issue #87)', () => {
       commander,
       page,
       output: path.join(directory.path, 'run'),
+      mode: TRACE_MODE.CHECKPOINTS,
+      network: false,
+      links: false,
       ...traceOptions,
     });
 
@@ -332,7 +335,7 @@ describe('trace recorder (issue #87)', () => {
       // before a freshly navigated document's own scripts do.
       assert.deepStrictEqual(
         page.state.initScripts.map((script) => script.name),
-        ['installMutationRecorderInPage']
+        ['installMutationRecorderInPage', 'installUserActionRecorderInPage']
       );
     });