browser-commander 0.20.0 → 0.21.1

package/tests/unit/browser/browser-cookie-lock.test.js

@@ -0,0 +1,102 @@
+import assert from 'node:assert/strict';
+import fs from 'node:fs/promises';
+import { syncBuiltinESMExports } from 'node:module';
+import os from 'node:os';
+import path from 'node:path';
+import { test } from 'node:test';
+
+import {
+  clearBrowserCookieMemoryCache,
+  getCachedCredential,
+} from '../../../src/browser/browser-cookie-cache.js';
+
+async function cleanup(t, directory) {
+  t.mock.restoreAll();
+  syncBuiltinESMExports();
+  clearBrowserCookieMemoryCache();
+  await fs.rm(directory, { recursive: true, force: true });
+}
+
+test('retries a Windows delete-pending credential lock without rereading the credential', async (t) => {
+  const directory = await fs.mkdtemp(path.join(os.tmpdir(), 'bc-cookie-lock-'));
+  const realOpen = fs.open;
+  let attempted = false;
+  let reads = 0;
+  // Model the observed Windows exclusive-open EPERM while the previous
+  // reader's lock is pending deletion. Other file operations stay real.
+  t.mock.method(fs, 'open', async (filename, ...args) => {
+    if (filename.endsWith('.lock') && !attempted) {
+      attempted = true;
+      throw Object.assign(new Error('lock pending deletion'), {
+        code: 'EPERM',
+      });
+    }
+    return realOpen(filename, ...args);
+  });
+  syncBuiltinESMExports();
+  try {
+    const options = {
+      cache: { enabled: true, dir: directory, ttlSeconds: 60 },
+      identity: 'windows-lock-contention',
+      refresh: false,
+      metadata: {},
+      platform: 'win32',
+      create: async () => {
+        reads += 1;
+        return Buffer.from('credential');
+      },
+    };
+    assert.deepEqual(
+      await getCachedCredential(options),
+      Buffer.from('credential')
+    );
+    clearBrowserCookieMemoryCache();
+    assert.deepEqual(
+      await getCachedCredential(options),
+      Buffer.from('credential')
+    );
+    assert.equal(reads, 1);
+    assert.ok(attempted);
+  } finally {
+    await cleanup(t, directory);
+  }
+});
+
+test('does not retry permanent permission errors or Unix EPERM', async (t) => {
+  const directory = await fs.mkdtemp(
+    path.join(os.tmpdir(), 'bc-cookie-denied-')
+  );
+  const realOpen = fs.open;
+  try {
+    for (const [platform, code] of [
+      ['win32', 'EACCES'],
+      ['linux', 'EPERM'],
+    ]) {
+      const error = Object.assign(new Error('access denied'), { code });
+      t.mock.method(fs, 'open', async (filename, ...args) => {
+        if (filename.endsWith('.lock')) {
+          throw error;
+        }
+        return realOpen(filename, ...args);
+      });
+      syncBuiltinESMExports();
+      await assert.rejects(
+        getCachedCredential({
+          cache: { enabled: true, dir: directory, ttlSeconds: 60 },
+          identity: platform,
+          refresh: false,
+          metadata: {},
+          platform,
+          create: async () => {
+            throw new Error('must not read credentials');
+          },
+        }),
+        (received) => received === error
+      );
+      t.mock.restoreAll();
+      syncBuiltinESMExports();
+    }
+  } finally {
+    await cleanup(t, directory);
+  }
+});

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

@@ -37,6 +37,7 @@ import {
   listBrowserProfiles as publicListBrowserProfiles,
   readBrowserCookies as publicReadBrowserCookies,
 } from '../../../src/index.js';
+import { writeFirefoxCookies } from '../../helpers/migration-fixtures.js';
 
 const CHROME_EPOCH_OFFSET_SECONDS = 11_644_473_600;
 const execFile = promisify(execFileCallback);
@@ -136,43 +137,12 @@ async function createFirefoxProfile({ homeDir, rows }) {
   const root = path.join(homeDir, '.mozilla', 'firefox');
   const profileName = 'fixture.default-release';
   const profilePath = path.join(root, profileName);
-  const cookiePath = path.join(profilePath, 'cookies.sqlite');
   await mkdir(profilePath, { recursive: true });
   await writeFile(
     path.join(root, 'profiles.ini'),
     `[Profile0]\nName=default-release\nIsRelative=1\nPath=${profileName}\nDefault=1\n`
   );
-  const database = await openSqliteDatabase(cookiePath);
-  database.exec(`
-    CREATE TABLE moz_cookies (
-      name TEXT,
-      value TEXT,
-      host TEXT,
-      path TEXT,
-      expiry INTEGER,
-      isSecure INTEGER,
-      isHttpOnly INTEGER,
-      sameSite INTEGER
-    );
-  `);
-  const insert = database.prepare(`
-    INSERT INTO moz_cookies
-      (name, value, host, path, expiry, isSecure, isHttpOnly, sameSite)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-  `);
-  for (const row of rows) {
-    insert.run(
-      row.name,
-      row.value,
-      row.host,
-      row.path ?? '/',
-      row.expiry ?? 0,
-      row.secure ? 1 : 0,
-      row.httpOnly ? 1 : 0,
-      row.sameSite ?? 0
-    );
-  }
-  database.close();
+  const cookiePath = await writeFirefoxCookies(profilePath, rows);
   return { cookiePath, profilePath, root };
 }
 

package/tests/unit/browser/cdp-session.test.js

@@ -0,0 +1,162 @@
+import { describe, it } from 'node:test';
+import assert from 'node:assert';
+
+import {
+  createCdpSession,
+  wrapCdpSession,
+} from '../../../src/browser/cdp-session.js';
+import { makeBrowserCommander } from '../../../src/factory.js';
+import * as publicApi from '../../../src/index.js';
+
+function createEngineSession() {
+  const calls = [];
+  const listeners = [];
+  return {
+    calls,
+    listeners,
+    detachCount: 0,
+    send(method, params) {
+      calls.push({ method, params });
+      return Promise.resolve({ echoed: method });
+    },
+    on(event, listener) {
+      listeners.push(['on', event, listener]);
+    },
+    once(event, listener) {
+      listeners.push(['once', event, listener]);
+    },
+    off(event, listener) {
+      listeners.push(['off', event, listener]);
+    },
+    detach() {
+      this.detachCount += 1;
+      return Promise.resolve();
+    },
+  };
+}
+
+function createPlaywrightPage(session) {
+  const context = {
+    targets: [],
+    newCDPSession(target) {
+      context.targets.push(target);
+      return Promise.resolve(session);
+    },
+  };
+  const page = { context: () => context, locator: () => ({}) };
+  return { page, context };
+}
+
+describe('createCdpSession', () => {
+  it('opens a Playwright session through page.context().newCDPSession(page)', async () => {
+    const session = createEngineSession();
+    const { page, context } = createPlaywrightPage(session);
+
+    const cdp = await createCdpSession(page, { engine: 'playwright' });
+
+    assert.equal(cdp.engine, 'playwright');
+    assert.equal(cdp.session, session);
+    assert.deepEqual(context.targets, [page]);
+  });
+
+  it('opens a Puppeteer session through page.createCDPSession()', async () => {
+    const session = createEngineSession();
+    const page = { createCDPSession: () => Promise.resolve(session) };
+
+    const cdp = await createCdpSession(page, { engine: 'puppeteer' });
+
+    assert.equal(cdp.engine, 'puppeteer');
+    assert.equal(cdp.session, session);
+  });
+
+  it('detects the engine from the page when it is not given', async () => {
+    const session = createEngineSession();
+    const { page } = createPlaywrightPage(session);
+
+    assert.equal((await createCdpSession(page)).engine, 'playwright');
+  });
+
+  it('accepts the older {browser, page, engine} form', async () => {
+    const session = createEngineSession();
+    const page = { createCDPSession: () => Promise.resolve(session) };
+
+    const cdp = await createCdpSession({
+      browser: {},
+      page,
+      engine: 'puppeteer',
+    });
+
+    assert.equal(cdp.session, session);
+  });
+
+  it('requires a page', async () => {
+    await assert.rejects(() => createCdpSession(undefined), /requires a page/u);
+  });
+});
+
+describe('the uniform CDP session surface', () => {
+  it('sends commands with empty params by default', async () => {
+    const session = createEngineSession();
+    const cdp = wrapCdpSession(session, 'puppeteer');
+
+    assert.deepEqual(await cdp.send('Browser.getVersion'), {
+      echoed: 'Browser.getVersion',
+    });
+    await cdp.send('Runtime.evaluate', { expression: '1' });
+    assert.deepEqual(session.calls, [
+      { method: 'Browser.getVersion', params: {} },
+      { method: 'Runtime.evaluate', params: { expression: '1' } },
+    ]);
+  });
+
+  it('forwards listeners and chains', () => {
+    const session = createEngineSession();
+    const cdp = wrapCdpSession(session, 'playwright');
+    const listener = () => {};
+
+    assert.equal(cdp.on('Network.requestWillBeSent', listener), cdp);
+    assert.equal(cdp.once('Page.loadEventFired', listener), cdp);
+    assert.equal(cdp.off('Network.requestWillBeSent', listener), cdp);
+    assert.deepEqual(
+      session.listeners.map(([kind, event]) => `${kind}:${event}`),
+      [
+        'on:Network.requestWillBeSent',
+        'once:Page.loadEventFired',
+        'off:Network.requestWillBeSent',
+      ]
+    );
+  });
+
+  it('detaches once', async () => {
+    const session = createEngineSession();
+    const cdp = wrapCdpSession(session, 'playwright');
+
+    await cdp.detach();
+    await cdp.detach();
+
+    assert.equal(session.detachCount, 1);
+  });
+});
+
+describe('public cdpSession entry points', () => {
+  it('exports createCdpSession and wrapCdpSession', () => {
+    assert.equal(publicApi.createCdpSession, createCdpSession);
+    assert.equal(publicApi.wrapCdpSession, wrapCdpSession);
+  });
+
+  it('opens a session from a commander', async () => {
+    const session = createEngineSession();
+    const { page } = createPlaywrightPage(session);
+    const commander = makeBrowserCommander({
+      page,
+      enableNetworkTracking: false,
+      enableNavigationManager: false,
+      enableDialogManager: false,
+    });
+
+    const cdp = await commander.createCdpSession();
+
+    assert.equal(cdp.engine, 'playwright');
+    assert.equal(cdp.session, session);
+  });
+});

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

@@ -3,6 +3,7 @@ import { describe, it } from 'node:test';
 
 import {
   connectBrowser,
+  pickForegroundPage,
   connectBrowserWithDependencies,
 } from '../../../src/browser/connector.js';
 import { connectBrowser as publicConnectBrowser } from '../../../src/index.js';
@@ -127,3 +128,25 @@ describe('connectBrowser', () => {
     );
   });
 });
+
+describe('pickForegroundPage', () => {
+  const page = (id, state) => ({ id, evaluate: async () => state });
+
+  it('prefers the visible tab over the first one', async () => {
+    const picked = await pickForegroundPage([
+      page('ntp', 'hidden'),
+      page('whats-new', 'visible'),
+    ]);
+    assert.equal(picked.id, 'whats-new');
+  });
+
+  it('falls back to the first tab when none reports visible', async () => {
+    const failing = {
+      id: 'crashed',
+      evaluate: async () => Promise.reject(new Error('gone')),
+    };
+    const picked = await pickForegroundPage([failing, page('b', 'hidden')]);
+    assert.equal(picked.id, 'crashed');
+    assert.equal(await pickForegroundPage([]), undefined);
+  });
+});