browser-commander 0.32.1 → 0.33.1

package/tests/unit/browser/webdriver.test.js

@@ -166,6 +166,31 @@ function launchDependencies(overrides = {}) {
   };
 }
 
+// Resolve through a fake Selenium Manager that answers browserPath.
+async function managerResolve(
+  options,
+  { checkAccess = accessOnly(), browserPath }
+) {
+  const commands = [];
+  const resolved = await resolveWebDriverExecutable({
+    managerPath: '/sm',
+    checkAccess,
+    runCommand: async (file, args) => {
+      commands.push([file, ...args]);
+      return managerOutput({
+        driver_path: '/cache/chromedriver',
+        browser_path: browserPath,
+      });
+    },
+    ...options,
+  });
+  return { commands, resolved };
+}
+
+const SELENIUM_CFT = '/home/u/.cache/selenium/chrome/linux64/156.0/chrome';
+const PLAYWRIGHT_CFT =
+  '/home/u/.cache/ms-playwright/chromium-1243/chrome-linux64/chrome';
+
 describe('resolveWebDriverExecutable', () => {
   it('uses an explicit driverPath first', async () => {
     const resolved = await resolveWebDriverExecutable({
@@ -210,21 +235,38 @@ describe('resolveWebDriverExecutable', () => {
     assert.equal(resolved.driverPath, 'C:\\b\\chromedriver.exe');
   });
 
-  it('then asks Selenium Manager for a matching driver', async () => {
-    const commands = [];
-    const resolved = await resolveWebDriverExecutable({
-      executablePath: '/usr/bin/google-chrome',
-      environment: { PATH: '' },
-      managerPath: '/sm',
-      checkAccess: accessOnly(),
-      runCommand: async (file, args) => {
-        commands.push([file, ...args]);
-        return managerOutput({
-          driver_path: '/cache/chromedriver',
-          browser_path: '/usr/bin/google-chrome',
-        });
-      },
+  // A chromedriver on PATH drives the installed Google Chrome: never used
+  // for Chrome for Testing (issue #179). Selenium Manager returns a PATH
+  // driver of another release too, so it is told to skip it (run
+  // 39651456089: ChromeDriver 155 for Chrome 153).
+  for (const cft of [PLAYWRIGHT_CFT, SELENIUM_CFT]) {
+    it(`matches ${cft} with its own driver, not the one on PATH (issue #179)`, async () => {
+      const { commands, resolved } = await managerResolve(
+        { executablePath: cft, environment: { PATH: '/bin' } },
+        { checkAccess: accessOnly('/bin/chromedriver'), browserPath: cft }
+      );
+      assert.deepEqual(commands, [
+        [
+          '/sm',
+          '--browser',
+          'chrome',
+          '--output',
+          'json',
+          '--browser-path',
+          cft,
+          '--skip-driver-in-path',
+        ],
+      ]);
+      assert.equal(resolved.driverPath, '/cache/chromedriver');
+      assert.equal(resolved.source, 'selenium-manager');
     });
+  }
+
+  it('then asks Selenium Manager for a matching driver', async () => {
+    const { commands, resolved } = await managerResolve(
+      { executablePath: '/usr/bin/google-chrome', environment: { PATH: '' } },
+      { browserPath: '/usr/bin/google-chrome' }
+    );
     assert.deepEqual(commands, [
       [
         '/sm',
@@ -381,6 +423,45 @@ describe('launchWebDriver', () => {
     await session.close(); // idempotent
   });
 
+  it('adds the Chrome for Testing defaults for the browser it resolves (issue #179)', async () => {
+    const launchWith = async (browserPath, options = {}) => {
+      const { mock, dependencies } = launchDependencies({
+        runCommand: async () =>
+          managerOutput({
+            driver_path: '/cache/chromedriver',
+            browser_path: browserPath,
+          }),
+      });
+      const session = await launchWebDriver(options, dependencies);
+      await session.close();
+      const { args } = mock.record.builders[0].options;
+      return {
+        defaults: session.defaultRestrictions,
+        switches: args.filter((arg) =>
+          ['--test-type=gpu', '--use-mock-keychain'].includes(arg)
+        ),
+      };
+    };
+
+    // Selenium Manager downloads Chrome for Testing when no Chrome is installed.
+    const cft = await launchWith(
+      '/home/u/.cache/selenium/chrome/linux64/131.0.6778.85/chrome'
+    );
+    assert.deepEqual(cft.defaults, [
+      'no-chrome-for-testing-infobar',
+      'mock-keychain',
+    ]);
+    assert.deepEqual(cft.switches, ['--test-type=gpu', '--use-mock-keychain']);
+
+    const chrome = await launchWith('/opt/google/chrome/chrome');
+    assert.deepEqual(chrome, { defaults: [], switches: [] });
+    const off = await launchWith(
+      '/home/u/.cache/selenium/chrome/linux64/131.0.6778.85/chrome',
+      { defaultRestrictions: [] }
+    );
+    assert.deepEqual(off, { defaults: [], switches: [] });
+  });
+
   it('starts geckodriver for Firefox with a -profile argument', async () => {
     const { mock, started, dependencies } = launchDependencies({
       environment: { PATH: '/usr/bin' },

package/tests/unit/scripts/check-web-archive.test.js

@@ -16,6 +16,7 @@ import {
   classifyStatus,
   extractRejectedLinks,
   judge,
+  ownRepositoryPath,
 } from '../../../../scripts/check-web-archive.mjs';
 
 // Verbatim shape of lychee/out.md from run 33959793880.
@@ -131,8 +132,8 @@ const waybackHas = (timestamp, archiveUrl) => async () => ({
   timestamp,
 });
 
-const verdictFor = (link, recheckImpl, waybackImpl) =>
-  judge(link, { recheckImpl, waybackImpl });
+const verdictFor = (link, recheckImpl, waybackImpl, extra = {}) =>
+  judge(link, { recheckImpl, waybackImpl, ...extra });
 
 describe('judging one rejected link', () => {
   const playwright = {
@@ -151,6 +152,14 @@ describe('judging one rejected link', () => {
     assert.equal(verdict.verdict, 'transient');
   });
 
+  it('does not fail for a host that answered 5xx and then timed out', async () => {
+    // chromium.googlesource.com answered 503 to lychee and then let the
+    // re-check time out: neither said the link is gone, and a host that
+    // answered at all still resolves.
+    const verdict = await verdictFor(playwright, unreachable(), waybackNever());
+    assert.equal(verdict.verdict, 'transient');
+  });
+
   it('does not fail for a host that keeps rate-limiting the runner', async () => {
     const verdict = await verdictFor(
       { url: 'https://example.com/x', status: '429' },
@@ -189,3 +198,69 @@ describe('judging one rejected link', () => {
     assert.equal(verdict.verdict, 'gone');
   });
 });
+
+describe('a link to a file this branch adds', () => {
+  // Run 39651456194: the READMEs link the new docs/chrome-for-testing.md on
+  // main, which is published to npm, PyPI and crates.io, so it must be an
+  // absolute URL. Until the pull request merges, main has no such file.
+  const repository = 'link-foundation/browser-commander';
+  const newDoc = {
+    url: 'https://github.com/link-foundation/browser-commander/blob/main/docs/chrome-for-testing.md',
+    status: '404',
+  };
+  const checkout = (...files) => ({
+    repository,
+    fileExists: (relative) => files.includes(relative),
+  });
+
+  it('maps this repository’s main-branch links to checkout paths', () => {
+    assert.equal(
+      ownRepositoryPath(`${newDoc.url}#verifying-it`, repository),
+      'docs/chrome-for-testing.md'
+    );
+    assert.equal(
+      ownRepositoryPath(
+        'https://github.com/link-foundation/browser-commander/tree/main/docs/case%20studies',
+        repository
+      ),
+      'docs/case studies'
+    );
+    assert.equal(
+      ownRepositoryPath(
+        'https://github.com/link-foundation/browser-commander/blob/v1/x.md',
+        repository
+      ),
+      null
+    );
+    assert.equal(
+      ownRepositoryPath(
+        'https://github.com/other/repo/blob/main/x.md',
+        repository
+      ),
+      null
+    );
+    assert.equal(ownRepositoryPath(newDoc.url, undefined), null);
+  });
+
+  it('does not fail when the checkout has the file main is about to get', async () => {
+    const verdict = await verdictFor(
+      newDoc,
+      () => {
+        throw new Error('a file in the checkout needs no network request');
+      },
+      waybackNever(),
+      checkout('docs/chrome-for-testing.md')
+    );
+    assert.equal(verdict.verdict, 'unmerged');
+  });
+
+  it('still fails when the checkout does not have the file either', async () => {
+    const verdict = await verdictFor(
+      newDoc,
+      answers(404),
+      waybackNothing(),
+      checkout('docs/feature-parity.md')
+    );
+    assert.equal(verdict.verdict, 'gone');
+  });
+});

package/tests/unit/traces/issue-162-defaults.test.js

@@ -181,7 +181,7 @@ describe('complete recording defaults (issue #162)', { timeout: 15000 }, () => {
         },
       };
       const launched = await launchBrowserWithDependencies(
-        { debug: { output } },
+        { channel: 'chrome', debug: { output } },
         {
           resolveSystem: async () => '/usr/bin/google-chrome',
           settleMs: 0,

package/tests/unit/traces/issue-166-policy.test.js

@@ -244,7 +244,7 @@ describe('opt-in recording policy (issue #166)', { timeout: 15000 }, () => {
     await fixture(async ({ root }) => {
       await assert.rejects(
         launchBrowserWithDependencies(
-          { debug: { directory: root } },
+          { channel: 'chrome', debug: { directory: root } },
           {
             resolveSystem: async () => '/usr/bin/google-chrome',
             launchRealBrowser: async () => {

package/tests/unit/traces/issue-180-screenshots.test.js

@@ -0,0 +1,173 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { startTrace } from '../../../src/traces/recorder.js';
+import { TRACE_MODE } from '../../../src/traces/schema.js';
+import { screenshot } from '../../../src/capture/index.js';
+import {
+  createFakeCommander,
+  createFakePage,
+  useTempTraceDirectory,
+} from '../../helpers/trace-fixtures.js';
+
+/**
+ * A clipped engine screenshot of a headful window can leave Chrome's emulated
+ * size stuck after a resize (issue #180). Without a fixed viewport, captures
+ * go through CDP `Page.captureScreenshot` with no `clip`.
+ */
+function cdpFake({ viewport = null, failWith, engine = 'playwright' } = {}) {
+  const calls = { cdp: [], engine: [], detached: 0 };
+  const session = {
+    send: async (method, params) => {
+      calls.cdp.push({ method, params });
+      if (failWith) {
+        throw new Error(failWith);
+      }
+      return { data: Buffer.from('cdp-png').toString('base64') };
+    },
+    detach: async () => {
+      calls.detached += 1;
+    },
+  };
+  const page = createFakePage();
+  page.screenshot = async (options) => {
+    calls.engine.push(options);
+    return Buffer.from('engine-png');
+  };
+  if (engine === 'playwright') {
+    page.context = () => ({ newCDPSession: async () => session });
+    page.viewportSize = () => viewport;
+  } else {
+    page.createCDPSession = async () => session;
+    page.viewport = () => viewport;
+  }
+  return { page, calls };
+}
+
+describe('trace checkpoint screenshots (issue #180)', () => {
+  const directory = useTempTraceDirectory();
+
+  async function checkpointShot(page, { withCommander = true, engine } = {}) {
+    const commander = createFakeCommander(page, engine ? { engine } : {});
+    const trace = await startTrace({
+      page,
+      ...(withCommander ? { commander } : {}),
+      output: path.join(directory.path, 'run'),
+      mode: TRACE_MODE.CHECKPOINTS,
+      network: false,
+      links: false,
+      screenshots: true,
+    });
+    await trace.checkpoint('resized');
+    const stopped = await trace.stop();
+    return (
+      await fs.readFile(path.join(stopped.path, 'checkpoints/0001.png'))
+    ).toString();
+  }
+
+  for (const engine of ['playwright', 'puppeteer']) {
+    for (const withCommander of [true, false]) {
+      it(`${engine} ${withCommander ? 'commander' : 'bare page'} without a fixed viewport sends no clip`, async () => {
+        const { page, calls } = cdpFake({ engine });
+        assert.equal(
+          await checkpointShot(page, { withCommander, engine }),
+          'cdp-png'
+        );
+        assert.deepEqual(calls.cdp, [
+          {
+            method: 'Page.captureScreenshot',
+            params: {
+              format: 'png',
+              fromSurface: false,
+              captureBeyondViewport: false,
+            },
+          },
+        ]);
+        assert.equal(calls.engine.length, 0);
+        assert.equal(calls.detached, 1);
+      });
+    }
+  }
+
+  it('a fixed viewport keeps the engine screenshot', async () => {
+    const { page, calls } = cdpFake({
+      viewport: { width: 800, height: 600 },
+    });
+    assert.equal(await checkpointShot(page), 'engine-png');
+    assert.equal(calls.cdp.length, 0);
+    assert.deepEqual(calls.engine, [{ type: 'png' }]);
+  });
+
+  it('falls back to the engine screenshot when the view cannot be captured', async () => {
+    const { page, calls } = cdpFake({
+      failWith: 'Unable to capture screenshot',
+    });
+    assert.equal(await checkpointShot(page), 'engine-png');
+    assert.equal(calls.cdp.length, 1);
+    assert.equal(calls.detached, 1);
+  });
+
+  it('a page without CDP keeps the engine screenshot', async () => {
+    const page = createFakePage();
+    assert.equal(
+      await checkpointShot(page, { withCommander: false }),
+      'fake-png'
+    );
+  });
+});
+
+describe('default commander screenshots (issue #180)', () => {
+  for (const engine of ['playwright', 'puppeteer']) {
+    it(`${engine} without a fixed viewport sends no clip`, async () => {
+      const { page, calls } = cdpFake({ engine });
+      assert.equal((await screenshot({ page, engine })).toString(), 'cdp-png');
+      assert.equal(calls.cdp.length, 1);
+      assert.equal('clip' in calls.cdp[0].params, false);
+      assert.equal(calls.engine.length, 0);
+    });
+
+    it(`${engine} with a fixed viewport keeps the engine screenshot`, async () => {
+      const { page, calls } = cdpFake({
+        engine,
+        viewport: { width: 800, height: 600 },
+      });
+      assert.equal(
+        (await screenshot({ page, engine })).toString(),
+        'engine-png'
+      );
+      assert.equal(calls.cdp.length, 0);
+      assert.equal(calls.engine[0].fullPage, false);
+    });
+  }
+
+  it('JPEG quality reaches the view capture', async () => {
+    const { page, calls } = cdpFake();
+    await screenshot({ page, format: 'jpeg', quality: 60 });
+    assert.deepEqual(calls.cdp[0].params, {
+      format: 'jpeg',
+      fromSurface: false,
+      captureBeyondViewport: false,
+      quality: 60,
+    });
+  });
+
+  for (const options of [
+    { fullPage: true },
+    { clip: { x: 0, y: 0, width: 1, height: 1 } },
+    { selector: '#pager' },
+    { omitBackground: true },
+    { hideScrollbars: true },
+    { animations: 'disabled' },
+    { scale: 'css' },
+    { stableViewport: false },
+  ]) {
+    it(`${JSON.stringify(options)} keeps the engine screenshot`, async () => {
+      const { page, calls } = cdpFake();
+      page.locator = () => ({ first: () => page });
+      await screenshot({ page, ...options });
+      assert.equal(calls.cdp.length, 0);
+      assert.equal(calls.engine.length, 1);
+    });
+  }
+});