browser-commander 0.32.1 → 0.33.0

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,93 @@
+// 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);
+  });
+});

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

@@ -1,6 +1,8 @@
-import { describe, it } from 'node:test';
+import { after, describe, it } from 'node:test';
 import assert from 'node:assert';
-import { access } from 'node:fs/promises';
+import { access, chmod, mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
 
 import {
   launchBrowser,
@@ -52,21 +54,59 @@ function fakeRealLauncher(calls, { engine = 'playwright' } = {}) {
 
 const systemChrome = async () => '/usr/bin/google-chrome';
 
+// An executable laid out like the Chrome for Testing Playwright downloads.
+const cftRoot = await mkdtemp(path.join(tmpdir(), 'browser-commander-cft-'));
+const cftChrome = path.join(
+  cftRoot,
+  'chromium-1248',
+  'chrome-linux64',
+  'chrome'
+);
+await mkdir(path.dirname(cftChrome), { recursive: true });
+await writeFile(cftChrome, '#!/bin/sh\n');
+await chmod(cftChrome, 0o755);
+after(() => rm(cftRoot, { recursive: true, force: true }));
+const cftEngine = async () => ({ executablePath: () => cftChrome });
+const missingEngine = async () => ({ executablePath: () => '/nonexistent' });
+const noCachedBrowsers = () => [];
+const noSystemChrome = async () => {
+  throw new Error('the installed Google Chrome must not be resolved');
+};
+
+// A real launch with recorded calls: the result and launchRealBrowser's options.
+async function realLaunch(options, dependencies, calls = []) {
+  const result = await launchBrowserWithDependencies(options, {
+    launchRealBrowser: fakeRealLauncher(calls),
+    settleMs: 0,
+    ...dependencies,
+  });
+  const [, launched] = calls.find(([name]) => name === 'launchRealBrowser');
+  return [result, launched];
+}
+
 describe('launchBrowser', () => {
-  it('starts the real browser by default, with nothing added (issue #103)', async () => {
+  it('starts Chrome for Testing by default, never the installed Google Chrome (issue #179)', async () => {
+    const [, options] = await realLaunch(
+      {},
+      { resolveSystem: noSystemChrome, loadEngineModule: cftEngine }
+    );
+    assert.equal(options.executablePath, cftChrome);
+    // No channel is invented: the launch is not Google Chrome's.
+    assert.equal('channel' in options, false);
+    // The Chrome for Testing defaults are added by launchRealBrowser.
+    assert.deepEqual(options.restrictions, []);
+    assert.equal('defaultRestrictions' in options, false);
+  });
+
+  it('starts the requested Google Chrome with nothing added (issue #103)', async () => {
     const calls = [];
     const googleBefore = process.env.GOOGLE_API_KEY;
 
-    const result = await launchBrowserWithDependencies(
-      {},
-      {
-        launchRealBrowser: fakeRealLauncher(calls),
-        resolveSystem: systemChrome,
-        settleMs: 0,
-      }
+    const [result, options] = await realLaunch(
+      { channel: 'chrome' },
+      { resolveSystem: systemChrome },
+      calls
     );
-
-    const [, options] = calls.find(([name]) => name === 'launchRealBrowser');
     assert.equal(options.engine, 'playwright');
     assert.equal(options.executablePath, '/usr/bin/google-chrome');
     assert.equal('slowMo' in options, false);
@@ -91,7 +131,7 @@ describe('launchBrowser', () => {
       { engine: 'puppeteer', restrictions: ['no-sync'], slowMo: 20 },
       {
         launchRealBrowser: fakeRealLauncher(calls, { engine: 'puppeteer' }),
-        resolveSystem: systemChrome,
+        loadEngineModule: cftEngine,
         settleMs: 0,
       }
     );
@@ -109,7 +149,7 @@ describe('launchBrowser', () => {
       { colorScheme: 'dark' },
       {
         launchRealBrowser: fakeRealLauncher(calls),
-        resolveSystem: systemChrome,
+        loadEngineModule: cftEngine,
         settleMs: 0,
       }
     );
@@ -128,7 +168,7 @@ describe('launchBrowser', () => {
           { fingerprint: { timezone: 'Not/AZone' } },
           {
             launchRealBrowser: fakeRealLauncher(calls),
-            resolveSystem: systemChrome,
+            loadEngineModule: cftEngine,
             settleMs: 0,
           }
         ),
@@ -150,6 +190,10 @@ describe('launchBrowser', () => {
       () => launchBrowser({ restrictions: ['no-such-restriction'] }),
       /Unknown launch restriction "no-such-restriction"/
     );
+    await assert.rejects(
+      () => launchBrowser({ defaultRestrictions: ['no-such-default'] }),
+      /Unknown launch restriction "no-such-default"/
+    );
   });
 
   describe("launch: 'engine'", () => {
@@ -233,6 +277,100 @@ describe('launchBrowser', () => {
       assert.deepEqual(calls.at(-1), ['browser.close']);
     });
 
+    it('adds the Chrome for Testing defaults to its engine launch (issue #179)', async () => {
+      const launchWith = async (options, executablePath) => {
+        const calls = [];
+        const engine = {
+          ...fakePlaywright(calls),
+          executablePath: () => executablePath,
+        };
+        const result = await launchBrowserWithDependencies(
+          { launch: 'engine', ...options },
+          { loadEngineModule: async () => engine, settleMs: 0 }
+        );
+        await result.close();
+        return { args: calls[0][2].args, defaults: result.defaultRestrictions };
+      };
+
+      const cft = await launchWith({}, cftChrome);
+      assert.deepEqual(cft.defaults, [
+        'no-chrome-for-testing-infobar',
+        'mock-keychain',
+      ]);
+      assert.ok(cft.args.includes('--test-type=gpu'));
+      assert.ok(cft.args.includes('--use-mock-keychain'));
+
+      for (const [options, executablePath] of [
+        [{}, '/home/u/.cache/ms-playwright/chromium-1100/chrome-linux/chrome'],
+        [{ channel: 'chrome' }, cftChrome],
+        [{ defaultRestrictions: [] }, cftChrome],
+      ]) {
+        const other = await launchWith(options, executablePath);
+        assert.deepEqual(other.defaults, [], JSON.stringify(options));
+        assert.equal(other.args.includes('--test-type=gpu'), false);
+        assert.equal(other.args.includes('--use-mock-keychain'), false);
+      }
+    });
+
+    it("points a Selenium launch at the engines' Chrome for Testing (issue #179)", async () => {
+      const launches = [];
+      const launchWebDriver = async (options) => {
+        launches.push(options);
+        return { driver: {}, page: fakePage(), close: async () => {} };
+      };
+      await launchBrowserWithDependencies(
+        {
+          engine: 'selenium',
+          launch: 'engine',
+          restrictions: ['no-sync'],
+          defaultRestrictions: ['mock-keychain'],
+        },
+        { launchWebDriver, loadEngineModule: cftEngine, settleMs: 0 }
+      );
+      assert.equal(launches[0].executablePath, cftChrome);
+      // launchWebDriver adds the defaults for the browser it resolves.
+      assert.deepEqual(launches[0].restrictions, ['no-sync']);
+      assert.deepEqual(launches[0].defaultRestrictions, ['mock-keychain']);
+
+      // An installed browser asked for by channel is left to Selenium.
+      await launchBrowserWithDependencies(
+        { engine: 'selenium', launch: 'engine', channel: 'chrome' },
+        { launchWebDriver, loadEngineModule: cftEngine, settleMs: 0 }
+      );
+      assert.equal(launches[1].executablePath, undefined);
+
+      // Selenium Manager's Chrome for Testing comes last...
+      const seleniumCft = process.execPath;
+      await launchBrowserWithDependencies(
+        { engine: 'selenium', launch: 'engine' },
+        {
+          launchWebDriver,
+          loadEngineModule: missingEngine,
+          cachedBrowsers: noCachedBrowsers,
+          seleniumManagerBrowser: async () => seleniumCft,
+          settleMs: 0,
+        }
+      );
+      assert.equal(launches[2].executablePath, seleniumCft);
+
+      // ...and without any the launch fails instead of letting the driver
+      // pick the installed Google Chrome.
+      await assert.rejects(
+        launchBrowserWithDependencies(
+          { engine: 'selenium', launch: 'engine' },
+          {
+            launchWebDriver,
+            loadEngineModule: missingEngine,
+            cachedBrowsers: noCachedBrowsers,
+            seleniumManagerBrowser: async () => undefined,
+            settleMs: 0,
+          }
+        ),
+        /Chrome for Testing is not installed for selenium/
+      );
+      assert.equal(launches.length, 3);
+    });
+
     it("leaves Ctrl+C to the caller with interruption: 'caller' (#174)", async () => {
       for (const [interruption, expected] of [
         [undefined, undefined],
@@ -279,34 +417,100 @@ describe('resolveLaunchExecutable', () => {
     ]);
   });
 
-  it("falls back to the engine's downloaded Chromium without an installed Chrome", async () => {
-    const notInstalled = async () => {
-      throw new Error('Chrome is not installed');
-    };
+  it("starts the engine's Chrome for Testing, never the installed Google Chrome", async () => {
     const executable = await resolveLaunchExecutable(
       { engine: 'playwright' },
-      {
-        resolveSystem: notInstalled,
-        loadEngineModule: async () => ({
-          executablePath: () => process.execPath,
-        }),
-      }
+      { resolveSystem: noSystemChrome, loadEngineModule: cftEngine }
     );
-    assert.equal(executable, process.execPath);
+    assert.equal(executable, cftChrome);
+  });
 
+  it('says how to install Chrome for Testing or ask for Google Chrome without it', async () => {
+    const missing = async () => ({
+      executablePath: () => '/nonexistent/chrome',
+    });
     await assert.rejects(
       () =>
         resolveLaunchExecutable(
           { engine: 'playwright' },
           {
-            resolveSystem: notInstalled,
-            loadEngineModule: async () => ({
-              executablePath: () => '/nonexistent/chrome',
-            }),
+            resolveSystem: noSystemChrome,
+            loadEngineModule: missing,
+            cachedBrowsers: noCachedBrowsers,
+          }
+        ),
+      /Chrome for Testing is not installed for playwright: run `npx playwright install chromium`, or pass channel: 'chrome'/
+    );
+    await assert.rejects(
+      () =>
+        resolveLaunchExecutable(
+          { engine: 'selenium' },
+          {
+            resolveSystem: noSystemChrome,
+            loadEngineModule: async () => {
+              throw new Error('not installed');
+            },
+            seleniumManagerBrowser: async () => {
+              throw new Error('offline');
+            },
+            cachedBrowsers: noCachedBrowsers,
           }
         ),
-      /Chrome is not installed/
+      /run `npx playwright install chromium` or `npx puppeteer browsers install chrome` or `selenium-manager --browser chrome --force-browser-download`/
+    );
+  });
+
+  it("falls back to Selenium Manager's Chrome for Testing for Selenium only", async () => {
+    const asked = [];
+    const seleniumManagerBrowser = async () => {
+      asked.push('selenium-manager');
+      return cftChrome;
+    };
+    assert.equal(
+      await resolveLaunchExecutable(
+        { engine: 'selenium' },
+        {
+          resolveSystem: noSystemChrome,
+          loadEngineModule: missingEngine,
+          seleniumManagerBrowser,
+          cachedBrowsers: noCachedBrowsers,
+        }
+      ),
+      cftChrome
+    );
+    await assert.rejects(
+      resolveLaunchExecutable(
+        { engine: 'playwright' },
+        {
+          resolveSystem: noSystemChrome,
+          loadEngineModule: missingEngine,
+          seleniumManagerBrowser,
+          cachedBrowsers: noCachedBrowsers,
+        }
+      ),
+      /Chrome for Testing is not installed for playwright/
+    );
+    assert.deepEqual(asked, ['selenium-manager']);
+  });
+
+  it("falls back to a cached build when the engine's own is not installed", async () => {
+    const asked = [];
+    const resolved = await resolveLaunchExecutable(
+      { engine: 'selenium' },
+      {
+        resolveSystem: noSystemChrome,
+        loadEngineModule: missingEngine,
+        cachedBrowsers: (engine) => {
+          asked.push(engine);
+          return ['/nonexistent/chrome-linux64/chrome', cftChrome];
+        },
+        seleniumManagerBrowser: async () => {
+          throw new Error('Selenium Manager is asked only without a cache');
+        },
+      }
     );
+    assert.equal(resolved, cftChrome);
+    assert.deepEqual(asked, ['selenium']);
   });
 });
 

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

@@ -264,6 +264,25 @@ describe('measureParity', () => {
     );
   });
 
+  it("accepts Chrome for Testing's default switches as requested (issue #179)", async () => {
+    const { session, dependencies } = fakes({
+      candidateCommandLine: `${CHROME} --user-data-dir=/tmp/c --remote-debugging-port=2 --test-type=gpu --use-mock-keychain about:blank`,
+    });
+    session.args = [
+      '--user-data-dir=/tmp/c',
+      '--remote-debugging-port=2',
+      '--test-type=gpu',
+      '--use-mock-keychain',
+    ];
+    session.defaultRestrictions = [
+      'no-chrome-for-testing-infobar',
+      'mock-keychain',
+    ];
+    const report = await measureParity({}, dependencies);
+    assert.equal(report.ok, true);
+    assert.deepEqual(report.unlisted, []);
+  });
+
   it('measures a provided session and leaves it open', async () => {
     const { calls, session, dependencies } = fakes({
       candidateCommandLine: `${CHROME} --user-data-dir=/tmp/c --remote-debugging-port=2 about:blank`,

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

@@ -516,6 +516,58 @@ describe('launchAndConnectRealBrowser', () => {
     await result.close();
   });
 
+  it('adds the Chrome for Testing defaults to its command line only (issue #179)', async () => {
+    const cft =
+      '/home/u/.cache/ms-playwright/chromium-1248/chrome-linux64/chrome';
+    const launch = async (executablePath, options = {}) => {
+      let spawnedArgs;
+      const result = await launchAndConnectRealBrowserWithDependencies(
+        { closeTimeout: 50, ...options },
+        {
+          resolveExecutable: async () => executablePath,
+          reservePort: async () => 40006,
+          spawnBrowser: (_executablePath, args) => {
+            spawnedArgs = args;
+            return fakeProcess([]);
+          },
+          waitForEndpoint: async () => 'http://127.0.0.1:40006',
+          connect: async () => ({ browser: null, page: null }),
+        }
+      );
+      await result.close();
+      return { args: spawnedArgs, defaults: result.defaultRestrictions };
+    };
+    const defaultSwitches = (args) =>
+      args.filter((arg) =>
+        ['--test-type=gpu', '--use-mock-keychain'].includes(arg)
+      );
+
+    const testing = await launch(cft);
+    assert.deepEqual(testing.defaults, [
+      'no-chrome-for-testing-infobar',
+      'mock-keychain',
+    ]);
+    assert.deepEqual(defaultSwitches(testing.args), [
+      '--test-type=gpu',
+      '--use-mock-keychain',
+    ]);
+
+    // Google Chrome keeps the clean command line of issue #103.
+    const chrome = await launch('/opt/google/chrome');
+    assert.deepEqual(chrome.defaults, []);
+    assert.deepEqual(defaultSwitches(chrome.args), []);
+
+    // defaultRestrictions replaces the defaults; [] turns them off.
+    const off = await launch(cft, { defaultRestrictions: [] });
+    assert.deepEqual(defaultSwitches(off.args), []);
+    const keychainOnly = await launch(cft, {
+      defaultRestrictions: ['mock-keychain'],
+    });
+    assert.deepEqual(defaultSwitches(keychainOnly.args), [
+      '--use-mock-keychain',
+    ]);
+  });
+
   it('terminates the spawned browser when connection fails', async () => {
     temporaryDirectory = await makeDedicatedProfile();
     let killed = false;