browser-commander 0.29.0 → 0.30.1

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/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']
       );
     });
 

package/tests/unit/utilities/subprocess.test.js

@@ -1,14 +1,18 @@
 import { describe, it } from 'node:test';
 import assert from 'node:assert';
+import * as fs from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
 import {
   CommandError,
   runCommand,
   startProcess,
 } from '../../../src/utilities/subprocess.js';
+import { repoPath } from '../../helpers/repo.js';
 
 const node = process.execPath;
 
-describe('runCommand', () => {
+describe('runCommand', { timeout: 10000 }, () => {
   it('passes arguments without a shell and captures output', async () => {
     const result = await runCommand(node, [
       '-e',
@@ -46,9 +50,25 @@ describe('runCommand', () => {
     const result = await runCommand(node, args, { check: false });
     assert.equal(result.code, 3);
   });
+
+  it('reports a missing executable as exit 127 with ENOENT diagnostics', async () => {
+    const file = path.join(tmpdir(), 'bc-missing-executable-164', 'missing');
+    await assert.rejects(
+      () => runCommand(file),
+      (error) => {
+        assert.ok(error instanceof CommandError);
+        assert.equal(error.code, 127);
+        assert.match(error.stderr, /ENOENT/);
+        return true;
+      }
+    );
+    const result = await runCommand(file, [], { check: false });
+    assert.equal(result.code, 127);
+    assert.match(result.stderr, /ENOENT/);
+  });
 });
 
-describe('startProcess', () => {
+describe('startProcess', { timeout: 10000 }, () => {
   it('streams output and reports the exit code', async () => {
     const child = startProcess(node, [
       '-e',
@@ -78,3 +98,61 @@ describe('startProcess', () => {
     assert.notEqual(exitCode, 0);
   });
 });
+
+describe(
+  'startDetachedProcess',
+  {
+    timeout: 10000,
+    // Both the original 1.4.0 and 2.0.2 runner disable Windows detachment.
+    skip:
+      process.platform === 'win32' &&
+      'Command Stream only creates detached process groups on Unix',
+  },
+  () => {
+    it('lets the launcher exit while the detached child survives', async (t) => {
+      const directory = await fs.mkdtemp(
+        path.join(tmpdir(), 'bc-detached-164-')
+      );
+      const marker = path.join(directory, 'survived');
+      let pid;
+      const launcher = startProcess(node, [
+        repoPath('experiments', 'issue-164', 'detached-launcher.mjs'),
+        marker,
+      ]);
+      t.after(async () => {
+        launcher.kill();
+        if (pid) {
+          try {
+            process.kill(pid, 'SIGKILL');
+          } catch (error) {
+            if (error.code !== 'ESRCH') {
+              throw error;
+            }
+          }
+        }
+        await fs.rm(directory, { recursive: true, force: true });
+      });
+      let output = '';
+      launcher.stdout.on('data', (chunk) => {
+        output += chunk;
+        pid = Number(output.trim());
+      });
+      assert.equal(await launcher.exited, 0, launcher.stderrTail);
+      assert.ok(pid > 0);
+      await assert.rejects(fs.readFile(marker), { code: 'ENOENT' });
+      const deadline = Date.now() + 5000;
+      while (Date.now() < deadline) {
+        try {
+          assert.equal(await fs.readFile(marker, 'utf8'), 'survived');
+          return;
+        } catch (error) {
+          if (error.code !== 'ENOENT') {
+            throw error;
+          }
+          await new Promise((resolve) => setTimeout(resolve, 50));
+        }
+      }
+      assert.fail('detached child did not survive the launcher exit');
+    });
+  }
+);