browser-commander 0.32.1 → 0.33.1

package/src/browser/webdriver.js

@@ -42,6 +42,10 @@ import {
 } from './profile-directory.js';
 import { buildRealBrowserArgs } from './real-browser.js';
 import { resolveRestrictions } from './restrictions.js';
+import {
+  defaultRestrictionsFor,
+  isChromeForTesting,
+} from './launch-executable.js';
 import { findBrowserSource } from './browser-sources.js';
 import {
   isSafariChannel,
@@ -218,7 +222,12 @@ export async function resolveWebDriverExecutable({
     };
   }
 
-  const onPath = await findOnPath(name, { environment, platform, checkAccess });
+  // A driver on PATH belongs to an installed browser; Chrome for Testing gets
+  // the driver of its own release from Selenium Manager (issue #179).
+  const ownDriver = isChromeForTesting(executablePath);
+  const onPath =
+    !ownDriver &&
+    (await findOnPath(name, { environment, platform, checkAccess }));
   if (onPath) {
     return {
       driverPath: onPath,
@@ -227,11 +236,39 @@ export async function resolveWebDriverExecutable({
     };
   }
 
+  return await askSeleniumManager({
+    browser,
+    name,
+    executablePath,
+    ownDriver,
+    environment,
+    platform,
+    runCommand,
+    managerPath,
+  });
+}
+
+/** Ask Selenium Manager for the driver of `browser` (and the browser itself). */
+async function askSeleniumManager({
+  browser,
+  name,
+  executablePath,
+  ownDriver,
+  environment,
+  platform,
+  runCommand,
+  managerPath,
+}) {
   const manager = managerPath ?? seleniumManagerPath({ platform, environment });
-  const args = ['--browser', browser, '--output', 'json'];
-  if (executablePath) {
-    args.push('--browser-path', executablePath);
-  }
+  const args = [
+    '--browser',
+    browser,
+    '--output',
+    'json',
+    ...(executablePath ? ['--browser-path', executablePath] : []),
+    // Selenium Manager itself prefers a driver on PATH, whatever its release.
+    ...(ownDriver ? ['--skip-driver-in-path'] : []),
+  ];
   const { stdout, code } = await runCommand(manager, args, { check: false });
   let output;
   try {
@@ -480,13 +517,14 @@ async function teardown({
  * @param {boolean} [options.bidi=false] - Enable WebDriver BiDi (events, preload scripts, full-page screenshots)
  * @param {string[]} [options.args] - Extra browser arguments
  * @param {string[]} [options.restrictions] - Chrome launch restrictions (launch-restrictions.json)
+ * @param {string[]} [options.defaultRestrictions] - Restrictions that replace the browser's defaults (the 'chrome-for-testing' preset for Chrome for Testing, none otherwise); [] turns them off
  * @param {boolean} [options.automationParity=true] - Keep navigator.webdriver false in headless Chrome
  * @param {Object<string,string>} [options.env] - Extra environment for the driver and browser
  * @param {number} [options.startupTimeout=30000]
  * @param {boolean} [options.verbose=false] - Mirror the driver server's output
  * @param {'managed'|'caller'} [options.interruption='managed'] - Who handles Ctrl+C for the driver server and the browser under it; see `startProcess`
  * @param {Object} [dependencies] - Injected selenium modules, runCommand, startProcess, fetch, reservePort, environment, platform (tests)
- * @returns {Promise<{driver: Object, page: Object, close: function(): Promise<void>, serverUrl: string, driverProcess: Object, driverPath: string, driverSource: string, browser: string, userDataDir: string, temporaryProfile: boolean, args: Array<string>, bidi: boolean}>}
+ * @returns {Promise<{driver: Object, page: Object, close: function(): Promise<void>, serverUrl: string, driverProcess: Object, driverPath: string, driverSource: string, browser: string, userDataDir: string, temporaryProfile: boolean, args: Array<string>, bidi: boolean, defaultRestrictions: Array<string>}>}
  */
 export async function launchWebDriver(options = {}, dependencies = {}) {
   if (!isSafariChannel(options.browser ?? 'chrome')) {
@@ -550,6 +588,17 @@ function withDriverContext(error, { serverUrl, exitCode, output }) {
   );
 }
 
+// Chrome for Testing - the engines' download or Selenium Manager's - gets its
+// default restrictions like any other launch of it (issue #179).
+function launchDefaultRestrictions(
+  { browser = 'chrome', debuggerAddress, defaultRestrictions },
+  browserPath
+) {
+  return browser === 'chrome' && !debuggerAddress
+    ? defaultRestrictionsFor(browserPath, defaultRestrictions)
+    : [];
+}
+
 async function launchWebDriverOnce(options, dependencies) {
   const {
     browser = 'chrome',
@@ -593,12 +642,17 @@ async function launchWebDriverOnce(options, dependencies) {
     executablePath,
   });
 
+  const defaultRestrictions = launchDefaultRestrictions(
+    options,
+    resolved.browserPath
+  );
+  const launchRestrictions = [...defaultRestrictions, ...restrictions];
   const temporaryProfile = !safari && !debuggerAddress && !requestedUserDataDir;
   const userDataDir =
     safari || debuggerAddress
       ? undefined
       : await resolveProfile(browser, requestedUserDataDir);
-  const childEnv = driverEnvironment(restrictions, env);
+  const childEnv = driverEnvironment(launchRestrictions, env);
 
   let driverProcess;
   let driver;
@@ -636,7 +690,7 @@ async function launchWebDriverOnce(options, dependencies) {
       remoteDebuggingPort:
         browser === 'chrome' ? await reservePort() : undefined,
       headless,
-      restrictions,
+      restrictions: launchRestrictions,
       disableFeatures,
       args,
       automationParity,
@@ -675,6 +729,7 @@ async function launchWebDriverOnce(options, dependencies) {
       temporaryProfile,
       args: built.args,
       bidi,
+      defaultRestrictions,
     };
   } catch (error) {
     const exitCode = driverProcess?.exitCode;

package/src/capture/screenshot.js

@@ -10,6 +10,7 @@ import { captureStableViewport, validateStableViewport } from './viewport.js';
  * @property {string} [path]
  * @property {boolean} [fullPage]
  * @property {boolean} [stableViewport] Capture only the existing view without visual styling.
+ *   Default captures already do so without a fixed viewport; false keeps the engine capture.
  * @property {string} [selector]
  * @property {Object} [element]
  * @property {{x:number,y:number,width:number,height:number}} [clip]
@@ -61,7 +62,7 @@ export async function screenshot(options = {}) {
   if (options.waitForFonts) {
     await page.evaluate(() => document.fonts.ready.then(() => true));
   }
-  if (options.stableViewport) {
+  if (capturesView(options, engine, css)) {
     if (engine === 'playwright') {
       native.scale = scale;
       native.caret = 'initial';
@@ -123,6 +124,20 @@ export async function screenshot(options = {}) {
   }
 }
 
+/**
+ * A default capture of a page without a fixed viewport takes the view as it
+ * is: a clipped engine capture can leave a resized window stuck (issue #180).
+ */
+function capturesView(options, engine, css) {
+  const { selector, element, clip, fullPage, omitBackground } = options;
+  return (
+    options.stableViewport ??
+    (['playwright', 'puppeteer'].includes(engine) &&
+      ![selector, element, clip, fullPage, omitBackground, css].some(Boolean) &&
+      (options.scale ?? 'device') === 'device')
+  );
+}
+
 async function finishScreenshot(
   bytes,
   { page, engine, scale, format, quality, output }

package/src/capture/viewport.js

@@ -28,7 +28,8 @@ export async function captureStableViewport(page, engine, native) {
   }
   let session;
   if (
-    (engine === 'playwright' && typeof page.context === 'function') ||
+    (engine === 'playwright' &&
+      typeof page.context?.()?.newCDPSession === 'function') ||
     (engine === 'puppeteer' &&
       (typeof page.createCDPSession === 'function' ||
         typeof page.target === 'function'))

package/src/exports.js

@@ -104,6 +104,11 @@ export {
   LAUNCH_MODES,
   resolveLaunchExecutable,
 } from './browser/launcher.js';
+export {
+  CHROME_FOR_TESTING_RESTRICTIONS,
+  defaultRestrictionsFor,
+  isChromeForTesting,
+} from './browser/launch-executable.js';
 export {
   LAUNCH_RESTRICTIONS,
   LAUNCH_RESTRICTION_PRESETS,

package/src/traces/recorder.js

@@ -21,6 +21,7 @@ import { startTraceDrain } from './drain-timer.js';
 import { attachRecorderObservers } from './observers.js';
 import { attachNetwork, validateNetworkOptions } from './network.js';
 import { startRecording } from '../capture/recording.js';
+import { captureStableViewport } from '../capture/viewport.js';
 import { normalizePrivacyOptions, redactValue } from './redaction.js';
 import path from 'node:path';
 import {
@@ -47,6 +48,17 @@ const DEFAULT_DOM_OPTIONS = Object.freeze({
   openShadowRoots: true,
 });
 
+/** The CDP-capable engine a bare page belongs to, or null for any other page. */
+function pageEngine(page) {
+  if (typeof page.context === 'function') {
+    return 'playwright';
+  }
+  return typeof page.createCDPSession === 'function' ||
+    typeof page.target === 'function'
+    ? 'puppeteer'
+    : null;
+}
+
 function normalizeMode(mode) {
   const values = Object.values(TRACE_MODE);
   if (!values.includes(mode)) {
@@ -275,12 +287,16 @@ export async function startTrace(options = {}) {
       return null;
     }
     try {
+      // A clipped engine capture can leave a resized headful window drawn at
+      // its old size (issue #180); without a fixed viewport, capture the view.
       const shot = await withDeadline(
-        page.screenshot({ type: 'png' }),
+        captureStableViewport(page, engine ?? pageEngine(page), {
+          type: 'png',
+        }),
         captureTimeoutMs,
         'trace screenshot'
       );
-      return Buffer.isBuffer(shot) ? shot : Buffer.from(shot);
+      return shot.bytes;
     } catch (error) {
       await bundle.drop({
         reason: TRACE_DROP_REASON.CAPTURE_FAILED,

package/tests/e2e/chrome-for-testing.e2e.test.js

@@ -0,0 +1,105 @@
+/**
+ * Issue #179: without a channel or executablePath every engine starts Chrome
+ * for Testing, hides its "only for automated testing" infobar and keeps it
+ * away from the user's keychain.
+ */
+// feature-parity: launch.chrome-for-testing@native-typed
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+
+import { isChromeForTesting } from '../../src/browser/launch-executable.js';
+import { launchBrowser } from '../../src/browser/launcher.js';
+import { readBrowserVersionPage } from '../../src/browser/parity.js';
+import { SANDBOX_ARGS } from '../helpers/e2e-browser.js';
+
+function skipReason() {
+  if (!process.env.RUN_E2E) {
+    return 'set RUN_E2E=true';
+  }
+  if (process.platform === 'linux' && !process.env.DISPLAY) {
+    return 'the infobar is only drawn in a window; run under xvfb-run';
+  }
+  return false;
+}
+
+/** What chrome://version reports about the browser a session started. */
+async function versionPage(engine, session) {
+  if (engine !== 'selenium') {
+    return await readBrowserVersionPage(session.page);
+  }
+  await session.browser.get('chrome://version');
+  return await session.browser.executeScript(`
+    const text = (id) => (document.getElementById(id)?.textContent ?? '').trim();
+    return { commandLine: text('command_line'), executablePath: text('executable_path') };
+  `);
+}
+
+/** Height of the browser UI above the page: tab strip, toolbar, infobars. */
+async function frameHeight(session) {
+  await session.page.goto('data:text/html,<title>frame</title>');
+  // The infobar appears just after the first window is shown.
+  await new Promise((resolve) => setTimeout(resolve, 1500));
+  return await session.page.evaluate(
+    () => globalThis.outerHeight - globalThis.innerHeight
+  );
+}
+
+describe(
+  'Chrome for Testing by default (issue #179)',
+  { skip: skipReason(), timeout: 180000 },
+  () => {
+    for (const engine of ['playwright', 'puppeteer', 'selenium']) {
+      it(`${engine} starts Chrome for Testing without its infobar or keychain`, async () => {
+        const session = await launchBrowser({
+          engine,
+          headless: false,
+          args: SANDBOX_ARGS,
+        });
+        try {
+          const { commandLine, executablePath } = await versionPage(
+            engine,
+            session
+          );
+          assert.equal(
+            isChromeForTesting(executablePath),
+            true,
+            executablePath
+          );
+          assert.deepEqual(session.defaultRestrictions, [
+            'no-chrome-for-testing-infobar',
+            'mock-keychain',
+          ]);
+          assert.match(commandLine, /--test-type=gpu(\s|$)/u);
+          assert.match(commandLine, /--use-mock-keychain(\s|$)/u);
+        } finally {
+          await session.close();
+        }
+      });
+    }
+
+    it('the default restrictions remove the infobar the opt-out shows', async () => {
+      const heights = {};
+      for (const [name, defaultRestrictions] of [
+        ['defaults', undefined],
+        ['opt-out', []],
+      ]) {
+        const session = await launchBrowser({
+          engine: 'playwright',
+          headless: false,
+          args: SANDBOX_ARGS,
+          ...(defaultRestrictions ? { defaultRestrictions } : {}),
+        });
+        try {
+          heights[name] = await frameHeight(session);
+        } finally {
+          await session.close();
+        }
+      }
+      // The infobar is about 40px tall; nothing else differs between the two.
+      assert.ok(
+        heights['opt-out'] - heights.defaults >= 20,
+        JSON.stringify(heights)
+      );
+    });
+  }
+);

package/tests/e2e/startup-readiness.e2e.test.js

@@ -44,6 +44,7 @@ it(
   async () => {
     const sibling = await launchBrowser({
       debug: false,
+      channel: 'chrome',
       headless: true,
       ...CHROME_LAUNCH_OPTIONS,
     });
@@ -58,6 +59,7 @@ it(
             launchAndConnectRealBrowserWithDependencies(
               {
                 debug: false,
+                channel: 'chrome',
                 headless: true,
                 persistSessionCookies: suppliedProfile,
                 ...(suppliedProfile ? { userDataDir: root } : {}),

package/tests/unit/browser/browser-handoff.test.js

@@ -109,6 +109,19 @@ describe('browser hand-off (issue #174)', () => {
     assert.deepEqual(await session.handoff(), handoffFor(endpoint));
   });
 
+  it('reattaches Selenium with the driver of the handed-off browser (issue #179)', async () => {
+    const endpoint = await fakeEndpoint();
+    const cft =
+      '/home/u/.cache/ms-playwright/chromium-1243/chrome-linux64/chrome';
+    const calls = [];
+    await reconnectBrowserWithDependencies(
+      handoffFor(endpoint, { executablePath: cft }),
+      {},
+      { connect: fakeConnect(calls) }
+    );
+    assert.equal(calls[0][1].executablePath, cft);
+  });
+
   it('reads a hand-off from a JSON file', async () => {
     const endpoint = await fakeEndpoint();
     const directory = await mkdtemp(path.join(os.tmpdir(), 'bc-handoff-'));

package/tests/unit/browser/chrome-for-testing-cache.test.js

@@ -0,0 +1,139 @@
+import assert from 'node:assert/strict';
+import { chmod, mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { after, describe, it } from 'node:test';
+import {
+  cacheLocations,
+  cachedChromeForTesting,
+  chromeForTestingCandidates,
+} from '../../../src/browser/chrome-for-testing-cache.js';
+import { isChromeForTesting } from '../../../src/browser/launch-executable.js';
+
+const home = await mkdtemp(path.join(tmpdir(), 'browser-commander-cache-'));
+after(() => rm(home, { recursive: true, force: true }));
+
+async function install(...segments) {
+  const file = path.join(home, ...segments);
+  await mkdir(path.dirname(file), { recursive: true });
+  await writeFile(file, '#!/bin/sh\n');
+  await chmod(file, 0o755);
+  return file;
+}
+
+const linux = (env = {}) =>
+  cacheLocations({ platform: 'linux', arch: 'x64', home, env });
+
+describe('Chrome for Testing in the download caches (issue #179)', () => {
+  it('lists the Playwright builds newest revision first', async () => {
+    const old = await install(
+      '.cache/ms-playwright/chromium-999/chrome-linux64/chrome'
+    );
+    const recent = await install(
+      '.cache/ms-playwright/chromium-1248/chrome-linux64/chrome'
+    );
+    await mkdir(
+      path.join(home, '.cache/ms-playwright/chromium_headless_shell-1300'),
+      {
+        recursive: true,
+      }
+    );
+    assert.deepEqual(chromeForTestingCandidates('playwright', linux()), [
+      recent,
+      old,
+    ]);
+  });
+
+  it('follows PLAYWRIGHT_BROWSERS_PATH and XDG_CACHE_HOME', async () => {
+    const moved = await install('moved/chromium-1300/chrome-linux64/chrome');
+    assert.deepEqual(
+      chromeForTestingCandidates(
+        'playwright',
+        linux({ PLAYWRIGHT_BROWSERS_PATH: path.join(home, 'moved') })
+      ),
+      [moved]
+    );
+    assert.deepEqual(
+      chromeForTestingCandidates(
+        'playwright',
+        linux({ PLAYWRIGHT_BROWSERS_PATH: '0' })
+      ),
+      []
+    );
+    const xdg = await install(
+      'xdg/ms-playwright/chromium-1/chrome-linux64/chrome'
+    );
+    assert.deepEqual(
+      chromeForTestingCandidates(
+        'playwright',
+        linux({ XDG_CACHE_HOME: path.join(home, 'xdg') })
+      ),
+      [xdg]
+    );
+  });
+
+  it('compares Puppeteer and Selenium versions numerically', async () => {
+    const newer = await install(
+      '.cache/puppeteer/chrome/linux-131.0.6778.204/chrome-linux64/chrome'
+    );
+    const older = await install(
+      '.cache/puppeteer/chrome/linux-99.0.1.1/chrome-linux64/chrome'
+    );
+    assert.deepEqual(chromeForTestingCandidates('puppeteer', linux()), [
+      newer,
+      older,
+    ]);
+    const selenium = await install(
+      '.cache/selenium/chrome/linux64/131.0.6778.85/chrome'
+    );
+    assert.deepEqual(chromeForTestingCandidates('selenium', linux()), [
+      selenium,
+    ]);
+    for (const file of [newer, older, selenium]) {
+      assert.ok(isChromeForTesting(file), file);
+    }
+  });
+
+  it('searches the caches each engine uses, in order', () => {
+    const machine = { platform: 'linux', arch: 'x64', home, env: {} };
+    const cacheOf = (file) =>
+      ['ms-playwright', 'puppeteer', 'selenium'].find((cache) =>
+        file.split(path.sep).includes(cache)
+      );
+    const caches = (engine) => [
+      ...new Set(cachedChromeForTesting(engine, machine).map(cacheOf)),
+    ];
+    assert.deepEqual(caches('playwright'), ['ms-playwright']);
+    assert.deepEqual(caches('puppeteer'), ['puppeteer']);
+    assert.deepEqual(caches('selenium'), [
+      'ms-playwright',
+      'puppeteer',
+      'selenium',
+    ]);
+  });
+
+  it('knows the macOS and Windows layouts and skips other platforms', () => {
+    assert.equal(
+      cacheLocations({ platform: 'darwin', arch: 'arm64', home, env: {} }).name,
+      'mac-arm64'
+    );
+    assert.equal(
+      cacheLocations({ platform: 'win32', arch: 'ia32', home, env: {} })
+        .puppeteer,
+      'win32'
+    );
+    assert.equal(
+      cacheLocations({ platform: 'linux', arch: 'arm64', home, env: {} }),
+      undefined
+    );
+    assert.deepEqual(
+      cachedChromeForTesting('playwright', {
+        platform: 'linux',
+        arch: 'arm64',
+        home,
+        env: {},
+      }),
+      []
+    );
+  });
+});

package/tests/unit/browser/launch-executable.test.js

@@ -0,0 +1,94 @@
+// feature-parity: launch.chrome-for-testing@native-typed
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+
+import {
+  CHROME_FOR_TESTING_RESTRICTIONS,
+  defaultRestrictionsFor,
+  isChromeForTesting,
+} from '../../../src/browser/launch-executable.js';
+import { resolveRestrictions } from '../../../src/browser/restrictions.js';
+import * as api from '../../../src/index.js';
+
+describe('isChromeForTesting (issue #179)', () => {
+  it('recognises the Chrome for Testing install layouts', () => {
+    for (const executable of [
+      // Playwright
+      '/home/u/.cache/ms-playwright/chromium-1248/chrome-linux64/chrome',
+      '/Users/u/Library/Caches/ms-playwright/chromium-1248/chrome-mac-arm64/Google Chrome for Testing.app/Contents/MacOS/Google Chrome for Testing',
+      'C:\\Users\\u\\AppData\\Local\\ms-playwright\\chromium-1248\\chrome-win64\\chrome.exe',
+      // Puppeteer and @puppeteer/browsers
+      '/home/u/.cache/puppeteer/chrome/linux-131.0.6778.85/chrome-linux64/chrome',
+      '/Users/u/.cache/puppeteer/chrome/mac_arm-131.0.6778.85/chrome-mac-arm64/Google Chrome for Testing.app/Contents/MacOS/Google Chrome for Testing',
+      'C:\\Users\\u\\.cache\\puppeteer\\chrome\\win32-131.0.6778.85\\chrome-win32\\chrome.exe',
+      '/Users/u/Library/Caches/ms-playwright/chromium-1248/chrome-mac-x64/Google Chrome for Testing.app/Contents/MacOS/Google Chrome for Testing',
+      // Selenium Manager
+      '/home/u/.cache/selenium/chrome/linux64/131.0.6778.85/chrome',
+      'C:\\Users\\u\\.cache\\selenium\\chrome\\win64\\131.0.6778.85\\chrome.exe',
+      // An app copied anywhere keeps its name
+      '/Applications/Google Chrome for Testing.app/Contents/MacOS/Google Chrome for Testing',
+    ]) {
+      assert.equal(isChromeForTesting(executable), true, executable);
+    }
+  });
+
+  it('leaves every other browser alone', () => {
+    for (const executable of [
+      undefined,
+      '',
+      '/usr/bin/google-chrome',
+      '/opt/google/chrome/chrome',
+      '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+      'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe',
+      '/usr/bin/chromium',
+      '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge',
+      // Playwright's own Chromium builds before Chrome for Testing
+      '/home/u/.cache/ms-playwright/chromium-1100/chrome-linux/chrome',
+      '/Users/u/Library/Caches/ms-playwright/chromium-1100/chrome-mac/Chromium.app/Contents/MacOS/Chromium',
+      // Selenium Manager's Firefox cache
+      '/home/u/.cache/selenium/firefox/linux64/133.0/firefox',
+    ]) {
+      assert.equal(isChromeForTesting(executable), false, String(executable));
+    }
+  });
+});
+
+describe('defaultRestrictionsFor (issue #179)', () => {
+  const cft =
+    '/home/u/.cache/ms-playwright/chromium-1248/chrome-linux64/chrome';
+
+  it('gives Chrome for Testing the chrome-for-testing preset', () => {
+    assert.deepEqual(defaultRestrictionsFor(cft), [
+      'no-chrome-for-testing-infobar',
+      'mock-keychain',
+    ]);
+    assert.deepEqual(defaultRestrictionsFor('/usr/bin/google-chrome'), []);
+  });
+
+  it("uses the caller's defaultRestrictions as given", () => {
+    assert.deepEqual(defaultRestrictionsFor(cft, []), []);
+    assert.deepEqual(
+      defaultRestrictionsFor('/usr/bin/google-chrome', ['mock-keychain']),
+      ['mock-keychain']
+    );
+    // The preset itself is never handed out to be mutated.
+    defaultRestrictionsFor(cft).push('no-sync');
+    assert.deepEqual(CHROME_FOR_TESTING_RESTRICTIONS, [
+      'no-chrome-for-testing-infobar',
+      'mock-keychain',
+    ]);
+  });
+
+  it('hides the infobar with --test-type=gpu and skips the keychain prompt', () => {
+    assert.deepEqual(resolveRestrictions(['chrome-for-testing']).args, [
+      '--test-type=gpu',
+      '--use-mock-keychain',
+    ]);
+    assert.deepEqual(api.LAUNCH_RESTRICTION_PRESETS['chrome-for-testing'], [
+      'no-chrome-for-testing-infobar',
+      'mock-keychain',
+    ]);
+    assert.equal(api.isChromeForTesting, isChromeForTesting);
+    assert.equal(api.defaultRestrictionsFor, defaultRestrictionsFor);
+  });
+});