browser-commander 0.24.0 → 0.25.0

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

@@ -49,6 +49,22 @@ async function installed(browser = 'safari', legacy = false) {
 }
 
 describe('Safari cookies', { timeout: 10000 }, () => {
+  it('uses whole domains for discovery while retaining reader substring filters', async () => {
+    const options = await installed();
+    const sources = await listCookieSources({
+      ...options,
+      domains: ['hub.com', 'github.co'],
+    });
+    assert.deepEqual(sources, []);
+    assert.deepEqual(
+      await readBrowserCookiesWithDependencies(
+        { browser: 'safari', domainFilter: 'hub.com', cache: false },
+        options
+      ),
+      expected.slice(0, 2)
+    );
+  });
+
   it('decodes multiple pages, flags, UTF-8 and Apple epoch without guessing session cookies', () => {
     assert.deepEqual(parseSafariCookies(fixture), expected);
   });
@@ -133,7 +149,16 @@ describe('Safari cookies', { timeout: 10000 }, () => {
     });
     assert.deepEqual(report.cookies, expected.slice(0, 2));
     assert.equal(report.migrated.cookies, 2);
-    assert.equal(report.skipped.length, 5);
+    const classes = JSON.parse(
+      await readFile(
+        repoPath('tests/fixtures/migration-data-classes.json'),
+        'utf8'
+      )
+    );
+    assert.deepEqual(
+      new Set(report.skipped.map((entry) => entry.type)),
+      new Set(classes.filter((type) => type !== 'cookies'))
+    );
     assert.equal(
       report.skipped.find((entry) => entry.type === 'passwords').reason,
       'safari-password-export-required'

package/tests/unit/browser/safari-profiles.test.js

@@ -0,0 +1,111 @@
+import assert from 'node:assert/strict';
+import { copyFile, mkdir, readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { it } from 'node:test';
+import Database from 'better-sqlite3';
+import { listBrowserProfiles } from '../../../src/browser/browser-profiles.js';
+import { listCookieSources } from '../../../src/browser/browser-cookies.js';
+import { findSafariCookieFile } from '../../../src/browser/safari-cookies.js';
+import { repoPath } from '../../helpers/repo.js';
+import { useTempDirectories } from '../../helpers/temp-directory.js';
+
+const temporary = useTempDirectories('bc-safari-stores-');
+const uuid = '11111111-2222-3333-4444-555555555555';
+
+it('discovers Safari named profiles and prefers WebKit stores to stale legacy cookies', async () => {
+  const homeDir = await temporary();
+  const root = path.join(
+    homeDir,
+    'Library/Containers/com.apple.Safari/Data/Library'
+  );
+  const named = path.join(root, 'Safari/Profiles', uuid);
+  await mkdir(named, { recursive: true });
+  const db = new Database(path.join(root, 'Safari/SafariTabs.db'));
+  db.exec(
+    await readFile(
+      repoPath('tests/fixtures/safari-data/SafariTabs.sql'),
+      'utf8'
+    )
+  );
+  db.close();
+  const locations = [
+    'Cookies',
+    'WebKit/WebsiteData/Default/Cookies',
+    `WebKit/WebsiteDataStore/${uuid}/Cookies`,
+  ];
+  for (const location of locations) {
+    await mkdir(path.join(root, location), { recursive: true });
+    await copyFile(
+      repoPath('tests/fixtures/safari/Cookies.binarycookies'),
+      path.join(root, location, 'Cookies.binarycookies')
+    );
+  }
+  const profiles = await listBrowserProfiles({
+    browser: 'safari',
+    platform: 'darwin',
+    homeDir,
+    environment: {},
+  });
+  assert.deepEqual(
+    profiles.map(({ name }) => name),
+    ['Default', uuid]
+  );
+  assert.equal(profiles[1].displayName, 'Work');
+  assert.equal(profiles[1].path, named);
+  assert.equal(
+    await findSafariCookieFile(root),
+    path.join(root, locations[1], 'Cookies.binarycookies')
+  );
+  assert.equal(
+    await findSafariCookieFile(named),
+    path.join(root, locations[2], 'Cookies.binarycookies')
+  );
+});
+
+it('preserves a Safari catalogue error while listing its readable cookies and other browsers', async () => {
+  const homeDir = await temporary();
+  const root = path.join(
+    homeDir,
+    'Library/Containers/com.apple.Safari/Data/Library'
+  );
+  await mkdir(path.join(root, 'Safari'), { recursive: true });
+  await mkdir(path.join(root, 'Cookies'));
+  await copyFile(
+    repoPath('tests/fixtures/safari/Cookies.binarycookies'),
+    path.join(root, 'Cookies/Cookies.binarycookies')
+  );
+  const tabs = path.join(root, 'Safari/SafariTabs.db');
+  new Database(tabs).close();
+  const chromium = path.join(
+    homeDir,
+    'Library/Application Support/Google/Chrome/Default'
+  );
+  await mkdir(chromium, { recursive: true });
+  const db = new Database(path.join(chromium, 'Cookies'));
+  db.exec(
+    "CREATE TABLE cookies(host_key TEXT); INSERT INTO cookies VALUES ('.github.com')"
+  );
+  db.close();
+  const before = await readFile(tabs);
+  const options = { platform: 'darwin', homeDir, environment: {} };
+  const profiles = await listBrowserProfiles(options);
+  assert.equal(
+    profiles.filter(({ browser }) => browser === 'safari').length,
+    2
+  );
+  const sources = await listCookieSources({
+    ...options,
+    domains: ['github.com'],
+  });
+  assert.equal(sources.find(({ browser }) => browser === 'chrome').cookies, 1);
+  assert.equal(
+    sources.find(({ browser, error }) => browser === 'safari' && !error)
+      .cookies,
+    4
+  );
+  assert.match(
+    sources.find(({ browser, error }) => browser === 'safari' && error).error,
+    /no such table/u
+  );
+  assert.deepEqual(await readFile(tabs), before);
+});

package/tests/unit/cli/dispatcher.test.js

@@ -182,8 +182,12 @@ describe('dispatcher: high-level methods', () => {
     const migrated = await dispatch('profile.migrate', {
       from: 'chrome',
       include: ['cookies'],
+      passwordCsv: '/tmp/export.csv',
+      includePaymentCards: true,
     });
     assert.deepEqual(migrated.options.include, ['cookies']);
+    assert.equal(migrated.options.passwordCsv, '/tmp/export.csv');
+    assert.equal(migrated.options.includePaymentCards, true);
     assert.deepEqual(await dispatch('doctor', {}), { ok: true, unlisted: [] });
     assert.equal((await dispatch('version')).language, 'js');
   });

package/tests/unit/cli/main.test.js

@@ -247,6 +247,9 @@ describe('runCli', () => {
       'cookies, bookmarks',
       '--domain',
       'a.test',
+      '--password-csv',
+      '/tmp/export.csv',
+      '--include-payment-cards',
     ]);
 
     // The source browser is grouped under `from` so migrateProfile receives
@@ -254,6 +257,8 @@ describe('runCli', () => {
     assert.equal(document.options.from.browser, 'chrome');
     assert.deepEqual(document.options.include, ['cookies', 'bookmarks']);
     assert.deepEqual(document.options.domains, ['a.test']);
+    assert.equal(document.options.passwordCsv, '/tmp/export.csv');
+    assert.equal(document.options.includePaymentCards, true);
   });
 
   it('lists cookie sources with per-domain counts', async () => {

package/tests/unit/scripts/browser-support.test.js

@@ -16,12 +16,13 @@ import { pathToFileURL } from 'node:url';
 
 import { repoPath } from '../../helpers/repo.js';
 
-const { BEGIN_MARKER, END_MARKER, readCatalogue, renderBrowserSupport } =
-  await import(pathToFileURL(repoPath('scripts/generate-browser-support.mjs')));
+const generator = await import(
+  pathToFileURL(repoPath('scripts/generate-browser-support.mjs'))
+);
 
 describe('generate-browser-support', () => {
   it('renders a row per browser with per-platform availability', () => {
-    const table = renderBrowserSupport([
+    const table = generator.renderBrowserSupport([
       {
         id: 'chrome',
         family: 'chromium',
@@ -47,10 +48,16 @@ describe('generate-browser-support', () => {
     const readme = fs
       .readFileSync(repoPath('README.md'), 'utf8')
       .replaceAll('\r\n', '\n');
-    const begin = readme.indexOf(BEGIN_MARKER);
-    const end = readme.indexOf(END_MARKER);
+    const begin = readme.indexOf(generator.BEGIN_MARKER);
+    const end = readme.indexOf(generator.END_MARKER);
     assert.ok(begin !== -1 && end > begin, 'README is missing the markers');
-    const between = readme.slice(begin + BEGIN_MARKER.length, end).trim();
-    assert.equal(between, renderBrowserSupport(readCatalogue(repoPath('.'))));
+    const between = readme
+      .slice(begin + generator.BEGIN_MARKER.length, end)
+      .trim();
+    const browsers = generator.readCatalogue(repoPath('.'));
+    assert.equal(
+      between,
+      `${generator.renderBrowserSupport(browsers)}\n\n${generator.renderBrowserControls(browsers)}`
+    );
   });
 });

package/tests/unit/scripts/check-pipeline-status.test.js

@@ -5,10 +5,12 @@
  * *failed*, and a run whose only casualty is a cancelled job is filed under
  * `cancelled` as well - run 24045269874 of this repository is one such run on
  * `main`. scripts/check-pipeline-status.sh is the only thing that looks at
- * that, so these tests pin the four readings it has to get right: a failure is
+ * that, so these tests pin the readings it has to get right: a failure is
  * always an error, a cancellation off the default branch is a warning, a
  * cancellation on the default branch is an error unless a newer run has already
  * taken over the branch head.
+ * Hosted-runner failures can report an undocumented abandoned result; it and
+ * other unexpected/missing results must fail on every branch.
  *
  * See docs/CI-TIMEOUT-BUDGETS.md.
  */
@@ -66,6 +68,36 @@ describe('check-pipeline-status.sh', { skip: !BASH_AVAILABLE }, () => {
     assert.match(output, /::error::Pipeline failed\. Failing jobs: lint/);
   });
 
+  for (const env of [
+    { IS_MAIN: 'false' },
+    { IS_MAIN: 'true', RUN_SHA: 'abc', BRANCH_HEAD_SHA: 'def' },
+  ]) {
+    it(`fails on an abandoned runner job with IS_MAIN=${env.IS_MAIN}`, () => {
+      // Hosted-runner acquisition failure in run 37362314527 left the macOS
+      // check cancelled, but GitHub sent "abandoned" to the needs context.
+      const { status, output } = runGate(
+        results({ lint: 'success', test: 'abandoned', release: 'skipped' }),
+        env
+      );
+
+      assert.equal(status, 1);
+      assert.match(output, /::error::Pipeline has unexpected job results/);
+      assert.match(output, /test \(abandoned\)/);
+      assert.doesNotMatch(output, /All required jobs succeeded/);
+    });
+  }
+
+  for (const result of ['timed_out', null, undefined]) {
+    it(`rejects an unexpected result of ${result}`, () => {
+      const { status, output } = runGate(results({ test: result }));
+
+      assert.equal(status, 1);
+      assert.match(output, /::error::Pipeline has unexpected job results/);
+      assert.match(output, /test \(/);
+      assert.doesNotMatch(output, /All required jobs succeeded/);
+    });
+  }
+
   it('only warns about a cancellation off the default branch', () => {
     const { status, output } = runGate(results({ test: 'cancelled' }), {
       IS_MAIN: 'false',

package/tests/unit/scripts/migration-support.test.js

@@ -0,0 +1,31 @@
+import assert from 'node:assert/strict';
+import { readFileSync } from 'node:fs';
+import { it } from 'node:test';
+import { pathToFileURL } from 'node:url';
+import { repoPath } from '../../helpers/repo.js';
+import { ALL_DATA_CLASSES } from '../../../src/browser/migration/index.js';
+
+const { BEGIN_MARKER, END_MARKER, readCapabilities, renderMigrationSupport } =
+  await import(
+    pathToFileURL(repoPath('scripts/generate-migration-support.mjs'))
+  );
+it('generates each source/target/class cell and declares unsupported target writers', () => {
+  const capabilities = readCapabilities(repoPath('.'));
+  assert.deepEqual(ALL_DATA_CLASSES, capabilities.classes);
+  const table = renderMigrationSupport(capabilities);
+  assert.equal(table.split('\n').length, 11);
+  assert.match(table, /safari\s+\| chromium\s+\| seed\s+\| translate/u);
+  const doc = readFileSync(
+    repoPath('docs/profile-migration.md'),
+    'utf8'
+  ).replaceAll('\r\n', '\n');
+  assert.equal(
+    doc
+      .slice(
+        doc.indexOf(BEGIN_MARKER) + BEGIN_MARKER.length,
+        doc.indexOf(END_MARKER)
+      )
+      .trim(),
+    table
+  );
+});