browser-commander 0.23.0 → 0.25.0

package/tests/unit/cli/selenium-parity.test.js

@@ -0,0 +1,186 @@
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+import { createDispatcher } from '../../../src/cli/dispatcher.js';
+import { buildLaunchOptions } from '../../../src/cli/sessions.js';
+import { launchBrowserWithDependencies } from '../../../src/browser/launcher.js';
+import { connectBrowserWithDependencies } from '../../../src/browser/connector.js';
+
+// feature-parity: engines.webdriver@native-typed engines.cli-matrix@native-typed
+
+describe('Selenium uses the common engine entry points', () => {
+  it('restores portable cookies and origin state through the common launcher', async () => {
+    const visited = [];
+    const seeded = [];
+    const page = {
+      url: () => 'about:blank',
+      goto: async (url) => {
+        visited.push(url);
+      },
+      setCookie: async (...cookies) => {
+        seeded.push(...cookies);
+      },
+      evaluateOnNewDocument: async () => {},
+      evaluate: async () => {},
+      bringToFront: async () => {},
+    };
+    const cookie = {
+      name: 'session',
+      value: 'value',
+      domain: 'example.com',
+      path: '/',
+      secure: true,
+    };
+    const result = await launchBrowserWithDependencies(
+      {
+        engine: 'selenium',
+        launch: 'engine',
+        storageState: {
+          cookies: [cookie],
+          origins: [
+            {
+              origin: 'https://example.com',
+              localStorage: [{ name: 'theme', value: 'dark' }],
+            },
+          ],
+        },
+      },
+      {
+        launchWebDriver: async () => ({
+          driver: {},
+          page,
+          close: async () => {},
+        }),
+        settleMs: 0,
+      }
+    );
+    assert.deepEqual(seeded, [cookie]);
+    assert.deepEqual(visited, ['https://example.com', 'about:blank']);
+    await result.close();
+  });
+  it('preserves WebDriver browser and driver options in the CLI', () => {
+    assert.deepEqual(
+      buildLaunchOptions({
+        engine: 'selenium',
+        browser: 'firefox',
+        driverPath: '/driver',
+        bidi: true,
+      }),
+      {
+        engine: 'selenium',
+        headless: false,
+        browser: 'firefox',
+        driverPath: '/driver',
+        bidi: true,
+      }
+    );
+  });
+
+  it('launches through the native driver without loading a CDP engine', async () => {
+    const page = { bringToFront: async () => {} };
+    const driver = {};
+    let options;
+    let closed = false;
+    const result = await launchBrowserWithDependencies(
+      { engine: 'selenium', launch: 'engine', extraArgs: ['--no-sandbox'] },
+      {
+        launchWebDriver: async (value) => {
+          options = value;
+          return {
+            driver,
+            page,
+            close: async () => {
+              closed = true;
+            },
+          };
+        },
+        settleMs: 0,
+      }
+    );
+    assert.equal(result.browser, driver);
+    assert.equal(result.page, page);
+    assert.deepEqual(options.args, ['--no-sandbox']);
+    await result.close();
+    assert.equal(closed, true);
+  });
+
+  it('connects to a Selenium Grid through the common connector', async () => {
+    const driver = {};
+    const page = {};
+    let options;
+    const result = await connectBrowserWithDependencies(
+      {
+        engine: 'selenium',
+        serverUrl: 'http://grid:4444',
+        capabilities: { browserName: 'firefox' },
+      },
+      {
+        connectWebDriver: async (value) => {
+          options = value;
+          return { driver, page, close: async () => {} };
+        },
+      }
+    );
+    assert.equal(result.browser, driver);
+    assert.equal(options.capabilities.browserName, 'firefox');
+  });
+
+  it('exposes the raw Selenium module and driver over generic handles', async () => {
+    const driver = { getTitle: async () => 'native driver' };
+    const page = {
+      waitForSelector: async () => ({
+        clear: async () => {},
+        sendKeys: async () => {},
+      }),
+      url: () => 'about:blank',
+    };
+    const dispatcher = createDispatcher({
+      dependencies: {
+        loadEngine: async (name) => {
+          assert.equal(name, 'selenium');
+          return { Builder: class Builder {} };
+        },
+        launchBrowser: async () => ({
+          browser: driver,
+          driver,
+          page,
+          close: async () => {},
+        }),
+      },
+    });
+    try {
+      const root = await dispatcher.dispatch('handle.root', {
+        name: 'selenium',
+      });
+      assert.ok(root.$handle);
+      const builder = await dispatcher.dispatch('handle.get', {
+        handle: root,
+        property: 'Builder',
+      });
+      const instance = await dispatcher.dispatch('handle.construct', {
+        handle: builder,
+      });
+      assert.equal(
+        (await dispatcher.dispatch('handle.describe', { handle: instance }))
+          .type,
+        'Builder'
+      );
+      await dispatcher.dispatch('session.launch', { engine: 'selenium' });
+      await dispatcher.dispatch('page.fill', {
+        selector: '#name',
+        value: 'Ada',
+      });
+      const handles = await dispatcher.dispatch('handle.root', {
+        name: 'session:s1',
+      });
+      assert.equal(
+        await dispatcher.dispatch('handle.call', {
+          handle: handles.browser,
+          method: 'getTitle',
+        }),
+        'native driver'
+      );
+    } finally {
+      await dispatcher.close();
+    }
+  });
+});

package/tests/unit/scripts/browser-support.test.js

@@ -16,12 +16,13 @@ import { pathToFileURL } from 'node:url';
 
 import { repoPath } from '../../helpers/repo.js';
 
-const { BEGIN_MARKER, END_MARKER, readCatalogue, renderBrowserSupport } =
-  await import(pathToFileURL(repoPath('scripts/generate-browser-support.mjs')));
+const generator = await import(
+  pathToFileURL(repoPath('scripts/generate-browser-support.mjs'))
+);
 
 describe('generate-browser-support', () => {
   it('renders a row per browser with per-platform availability', () => {
-    const table = renderBrowserSupport([
+    const table = generator.renderBrowserSupport([
       {
         id: 'chrome',
         family: 'chromium',
@@ -47,10 +48,16 @@ describe('generate-browser-support', () => {
     const readme = fs
       .readFileSync(repoPath('README.md'), 'utf8')
       .replaceAll('\r\n', '\n');
-    const begin = readme.indexOf(BEGIN_MARKER);
-    const end = readme.indexOf(END_MARKER);
+    const begin = readme.indexOf(generator.BEGIN_MARKER);
+    const end = readme.indexOf(generator.END_MARKER);
     assert.ok(begin !== -1 && end > begin, 'README is missing the markers');
-    const between = readme.slice(begin + BEGIN_MARKER.length, end).trim();
-    assert.equal(between, renderBrowserSupport(readCatalogue(repoPath('.'))));
+    const between = readme
+      .slice(begin + generator.BEGIN_MARKER.length, end)
+      .trim();
+    const browsers = generator.readCatalogue(repoPath('.'));
+    assert.equal(
+      between,
+      `${generator.renderBrowserSupport(browsers)}\n\n${generator.renderBrowserControls(browsers)}`
+    );
   });
 });

package/tests/unit/scripts/check-pipeline-status.test.js

@@ -5,10 +5,12 @@
  * *failed*, and a run whose only casualty is a cancelled job is filed under
  * `cancelled` as well - run 24045269874 of this repository is one such run on
  * `main`. scripts/check-pipeline-status.sh is the only thing that looks at
- * that, so these tests pin the four readings it has to get right: a failure is
+ * that, so these tests pin the readings it has to get right: a failure is
  * always an error, a cancellation off the default branch is a warning, a
  * cancellation on the default branch is an error unless a newer run has already
  * taken over the branch head.
+ * Hosted-runner failures can report an undocumented abandoned result; it and
+ * other unexpected/missing results must fail on every branch.
  *
  * See docs/CI-TIMEOUT-BUDGETS.md.
  */
@@ -66,6 +68,36 @@ describe('check-pipeline-status.sh', { skip: !BASH_AVAILABLE }, () => {
     assert.match(output, /::error::Pipeline failed\. Failing jobs: lint/);
   });
 
+  for (const env of [
+    { IS_MAIN: 'false' },
+    { IS_MAIN: 'true', RUN_SHA: 'abc', BRANCH_HEAD_SHA: 'def' },
+  ]) {
+    it(`fails on an abandoned runner job with IS_MAIN=${env.IS_MAIN}`, () => {
+      // Hosted-runner acquisition failure in run 37362314527 left the macOS
+      // check cancelled, but GitHub sent "abandoned" to the needs context.
+      const { status, output } = runGate(
+        results({ lint: 'success', test: 'abandoned', release: 'skipped' }),
+        env
+      );
+
+      assert.equal(status, 1);
+      assert.match(output, /::error::Pipeline has unexpected job results/);
+      assert.match(output, /test \(abandoned\)/);
+      assert.doesNotMatch(output, /All required jobs succeeded/);
+    });
+  }
+
+  for (const result of ['timed_out', null, undefined]) {
+    it(`rejects an unexpected result of ${result}`, () => {
+      const { status, output } = runGate(results({ test: result }));
+
+      assert.equal(status, 1);
+      assert.match(output, /::error::Pipeline has unexpected job results/);
+      assert.match(output, /test \(/);
+      assert.doesNotMatch(output, /All required jobs succeeded/);
+    });
+  }
+
   it('only warns about a cancellation off the default branch', () => {
     const { status, output } = runGate(results({ test: 'cancelled' }), {
       IS_MAIN: 'false',

package/tests/unit/scripts/migration-support.test.js

@@ -0,0 +1,31 @@
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { it } from 'node:test';
+import { pathToFileURL } from 'node:url';
+import { repoPath } from '../../helpers/repo.js';
+import { ALL_DATA_CLASSES } from '../../../src/browser/migration/index.js';
+
+const { BEGIN_MARKER, END_MARKER, readCapabilities, renderMigrationSupport } =
+  await import(
+    pathToFileURL(repoPath('scripts/generate-migration-support.mjs'))
+  );
+it('generates each source/target/class cell and declares unsupported target writers', () => {
+  const capabilities = readCapabilities(repoPath('.'));
+  assert.deepEqual(ALL_DATA_CLASSES, capabilities.classes);
+  const table = renderMigrationSupport(capabilities);
+  assert.equal(table.split('\n').length, 11);
+  assert.match(table, /safari\s+\| chromium\s+\| seed\s+\| translate/u);
+  const doc = readFileSync(
+    repoPath('docs/profile-migration.md'),
+    'utf8'
+  ).replaceAll('\r\n', '\n');
+  assert.equal(
+    doc
+      .slice(
+        doc.indexOf(BEGIN_MARKER) + BEGIN_MARKER.length,
+        doc.indexOf(END_MARKER)
+      )
+      .trim(),
+    table
+  );
+});

package/tests/unit/tests/index.test.js

@@ -26,12 +26,13 @@ describe('browser-commander/tests', () => {
     assert.deepStrictEqual(normalizeBrowserTestEngines(), [
       'playwright',
       'puppeteer',
+      'selenium',
     ]);
     assert.deepStrictEqual(normalizeBrowserTestEngines('Playwright'), [
       'playwright',
     ]);
     assert.throws(
-      () => normalizeBrowserTestEngines('selenium'),
+      () => normalizeBrowserTestEngines('unknown'),
       /Unsupported browser test engine/
     );
   });

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.20.0');
-    assert.match(installed.version, /^0\.20\./);
+    assert.strictEqual(manifest.dependencies['links-notation'], '^0.22.0');
+    assert.match(installed.version, /^0\.22\./);
   });
 
   it('should export a bundle named by path as readily as an open one', async () => {