browser-commander 0.32.1 → 0.33.1

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/migration/os-crypt-keys.test.js

@@ -6,6 +6,7 @@ import {
   createSourceKeyResolver,
   localStatePathForProfile,
   resolveTargetKey,
+  targetKeystoreFor,
 } from '../../../../src/browser/migration/os-crypt-keys.js';
 import { deriveChromiumCookieKey } from '../../../../src/browser/browser-cookie-crypto.js';
 
@@ -77,6 +78,45 @@ describe('resolveTargetKey', () => {
     assert.equal(result.prefix, 'v11');
   });
 
+  it('tags macOS keys v10, the only tag macOS Chromium reads', async () => {
+    const result = await resolveTargetKey({
+      browser: 'chromium',
+      platform: 'darwin',
+      readSafeStoragePassword: async () => 'target-pass',
+    });
+    assert.deepEqual(
+      result.key,
+      deriveChromiumCookieKey('target-pass', 'darwin')
+    );
+    assert.equal(result.prefix, 'v10');
+  });
+
+  it("uses Chromium's fixed mock passwords for a mock keystore (issue #179)", async () => {
+    const unreadable = async () => {
+      throw new Error('the OS keystore must not be asked');
+    };
+    const mac = await resolveTargetKey({
+      browser: 'chromium',
+      platform: 'darwin',
+      keystore: 'mock',
+      readSafeStoragePassword: unreadable,
+    });
+    assert.deepEqual(mac, {
+      key: deriveChromiumCookieKey('mock_password', 'darwin'),
+      prefix: 'v10',
+    });
+    const linux = await resolveTargetKey({
+      browser: 'chrome',
+      platform: 'linux',
+      keystore: 'mock',
+      readSafeStoragePassword: unreadable,
+    });
+    assert.deepEqual(linux, {
+      key: deriveChromiumCookieKey('peanuts', 'linux'),
+      prefix: 'v10',
+    });
+  });
+
   it('refuses to derive a Windows key', async () => {
     await assert.rejects(
       resolveTargetKey({ browser: 'chrome', platform: 'win32' }),
@@ -85,6 +125,23 @@ describe('resolveTargetKey', () => {
   });
 });
 
+describe('targetKeystoreFor (issue #179)', () => {
+  it('reports the switches that bypass the OS keystore', () => {
+    assert.equal(targetKeystoreFor(['--use-mock-keychain'], 'darwin'), 'mock');
+    assert.equal(
+      targetKeystoreFor(['--password-store=basic'], 'linux'),
+      'mock'
+    );
+    assert.equal(targetKeystoreFor(['--use-mock-keychain'], 'linux'), 'os');
+    assert.equal(
+      targetKeystoreFor(['--password-store=gnome-libsecret'], 'linux'),
+      'os'
+    );
+    assert.equal(targetKeystoreFor([], 'darwin'), 'os');
+    assert.equal(targetKeystoreFor(['--use-mock-keychain'], 'win32'), 'os');
+  });
+});
+
 describe('localStatePathForProfile', () => {
   it('points at Local State next to the profile directory', () => {
     assert.equal(

package/tests/unit/browser/migration/safari-data.test.js

@@ -24,6 +24,24 @@ const fixture = (name) =>
     )
   );
 
+function migratedPasswords(profile) {
+  const db = new Database(path.join(profile, 'Login Data'));
+  try {
+    return db.prepare('SELECT origin_url,password_value FROM logins').all();
+  } finally {
+    db.close();
+  }
+}
+
+const decryptPassword = (row, key, platform) =>
+  decryptChromiumCookie({
+    encryptedValue: row.password_value,
+    key,
+    platform,
+    databaseVersion: 0,
+    host: 'github.com',
+  });
+
 describe('Safari data sources', () => {
   for (const format of ['binary', 'xml']) {
     it(`preserves hierarchy and reading list from ${format} plist`, async () => {
@@ -103,25 +121,31 @@ describe('Safari data sources', () => {
         ({ reason }) => reason === 'safari-reading-list-translated'
       )
     );
-    const db = new Database(path.join(target, 'Login Data'));
-    try {
-      const rows = db
-        .prepare('SELECT origin_url,password_value FROM logins')
-        .all();
-      assert.equal(rows.length, 1);
-      assert.equal(
-        decryptChromiumCookie({
-          encryptedValue: rows[0].password_value,
-          key,
-          platform: 'linux',
-          databaseVersion: 0,
-          host: 'github.com',
-        }),
-        'p"a\nss'
-      );
-    } finally {
-      db.close();
-    }
+    const rows = migratedPasswords(target);
+    assert.equal(rows.length, 1);
+    assert.equal(decryptPassword(rows[0], key, 'linux'), 'p"a\nss');
+  });
+
+  it('encrypts migrated passwords with the mock keychain key of a Chrome for Testing launch (issue #179)', async () => {
+    const source = await temporary();
+    const target = await temporary();
+    // No keys are injected and the OS keystore is never asked: Chromium's
+    // --use-mock-keychain derives its key from the fixed "mock_password".
+    const report = await migrateProfile({
+      from: { browser: 'safari', userDataDir: source },
+      to: target,
+      include: ['passwords'],
+      domains: ['github.com'],
+      passwordCsv: fixture('Passwords.csv'),
+      platform: 'darwin',
+      targetBrowser: 'chromium',
+      targetKeystore: 'mock',
+    });
+    assert.equal(report.migrated.passwords, 1);
+    const [row] = migratedPasswords(target);
+    assert.equal(row.password_value.subarray(0, 3).toString(), 'v10');
+    const key = deriveChromiumCookieKey('mock_password', 'darwin');
+    assert.equal(decryptPassword(row, key, 'darwin'), 'p"a\nss');
   });
 
   it('names the executing app and retry link for non-cookie protection failures', async () => {

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

@@ -282,6 +282,28 @@ describe('launchAndConnectRealBrowser', () => {
     await access(path.join(temporaryDirectory, 'First Run'));
   });
 
+  it('gives Selenium the started browser so its driver matches it (issue #179)', async () => {
+    temporaryDirectory = await makeDedicatedProfile();
+    const cft =
+      '/home/u/.cache/ms-playwright/chromium-1243/chrome-linux64/chrome';
+    let connectOptions;
+    await launchAndConnectRealBrowserWithDependencies(
+      { engine: 'selenium', userDataDir: temporaryDirectory },
+      {
+        resolveExecutable: async () => cft,
+        reservePort: async () => 9444,
+        spawnBrowser: () => fakeProcess([]),
+        waitForEndpoint: async () => 'http://127.0.0.1:9444',
+        connect: async (options) => {
+          connectOptions = options;
+          return { browser: null, page: null };
+        },
+      }
+    );
+    assert.equal(connectOptions.engine, 'selenium');
+    assert.equal(connectOptions.executablePath, cft);
+  });
+
   it('migrates a profile before launch and seeds the migrated cookies', async () => {
     temporaryDirectory = await makeDedicatedProfile();
     const calls = [];
@@ -516,6 +538,109 @@ 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('migrates passwords with the key of the browser that starts (issue #179)', async () => {
+    const cft =
+      '/Users/u/Library/Caches/ms-playwright/chromium-1248/chrome-mac-arm64/Google Chrome for Testing.app/Contents/MacOS/Google Chrome for Testing';
+    const migrateTarget = async (executablePath, options = {}) => {
+      let migrateOptions;
+      const result = await launchAndConnectRealBrowserWithDependencies(
+        {
+          closeTimeout: 50,
+          migrateFrom: { browser: 'chrome', include: ['passwords'] },
+          ...options,
+        },
+        {
+          platform: 'darwin',
+          resolveExecutable: async () => executablePath,
+          reservePort: async () => 40007,
+          spawnBrowser: () => fakeProcess([]),
+          waitForEndpoint: async () => 'http://127.0.0.1:40007',
+          connect: async () => ({ browser: null, page: null }),
+          migrateProfile: async (migration) => {
+            migrateOptions = migration;
+            return { migrated: {}, skipped: [], warnings: [], cookies: [] };
+          },
+        }
+      );
+      await result.close();
+      const { targetBrowser, targetKeystore } = migrateOptions;
+      return { targetBrowser, targetKeystore };
+    };
+
+    // Chrome for Testing keeps "Chromium Safe Storage", and its default
+    // mock keychain encrypts with Chromium's fixed mock password.
+    assert.deepEqual(await migrateTarget(cft), {
+      targetBrowser: 'chromium',
+      targetKeystore: 'mock',
+    });
+    assert.deepEqual(await migrateTarget(cft, { defaultRestrictions: [] }), {
+      targetBrowser: 'chromium',
+      targetKeystore: 'os',
+    });
+    assert.deepEqual(await migrateTarget('/opt/google/chrome'), {
+      targetBrowser: 'chrome',
+      targetKeystore: 'os',
+    });
+    assert.deepEqual(
+      await migrateTarget('/opt/google/chrome', {
+        restrictions: ['mock-keychain'],
+      }),
+      { targetBrowser: 'chrome', targetKeystore: 'mock' }
+    );
+  });
+
   it('terminates the spawned browser when connection fails', async () => {
     temporaryDirectory = await makeDedicatedProfile();
     let killed = false;