browser-commander 0.20.0 → 0.21.0

package/tests/unit/browser/attach/snapshot-launch.test.js

@@ -0,0 +1,312 @@
+import assert from 'node:assert';
+import { access, mkdir, writeFile } from 'node:fs/promises';
+import path from 'node:path';
+import { describe, it } from 'node:test';
+
+import {
+  ATTACH_MODES,
+  attachUserBrowser,
+  describeAttachDifferences,
+  snapshotBrowserForChannel,
+  snapshotUserDataDir,
+} from '../../../../src/browser/attach/index.js';
+import {
+  prepareSnapshotLaunch,
+  validateAttachOption,
+} from '../../../../src/browser/attach/snapshot-launch.js';
+import { launchBrowserWithDependencies } from '../../../../src/browser/launcher.js';
+import { launchAndConnectRealBrowserWithDependencies } from '../../../../src/browser/real-browser.js';
+import * as publicApi from '../../../../src/exports.js';
+import { useTempDirectories } from '../../../helpers/temp-directory.js';
+
+const makeTempDir = useTempDirectories('bc-attach-launch-');
+
+/** A snapshot stand-in that creates an empty user data directory. */
+function fakeSnapshot(calls, extra = {}) {
+  return async (options) => {
+    calls.push(options);
+    const target = await makeTempDir();
+    return {
+      source: {
+        browser: options.browser,
+        profile: options.profile,
+        userDataDir: '/home/user/.config/google-chrome',
+      },
+      target,
+      copied: { files: 1, databases: 0 },
+      skipped: [],
+      warnings: [],
+      ...extra,
+    };
+  };
+}
+
+/** Launch seams that never start a process. */
+function fakeLaunchDependencies(calls) {
+  const exitListeners = [];
+  const browserProcess = {
+    exitCode: null,
+    kill() {
+      this.exit(143);
+    },
+    once: (event, listener) => exitListeners.push(listener),
+    exit(code) {
+      browserProcess.exitCode = code;
+      exitListeners.splice(0).forEach((listener) => listener(code));
+    },
+  };
+  return {
+    browserProcess,
+    dependencies: {
+      resolveExecutable: async () => '/opt/google/chrome',
+      reservePort: async () => 9555,
+      spawnBrowser: (executablePath, args) => {
+        calls.push(['spawn', args]);
+        return browserProcess;
+      },
+      waitForEndpoint: async () => 'http://127.0.0.1:9555',
+      connect: async () => ({ browser: { close: async () => {} }, page: {} }),
+    },
+  };
+}
+
+describe('describeAttachDifferences', () => {
+  it('lists the documented differences of every mode', () => {
+    assert.deepEqual(ATTACH_MODES, ['clean', 'snapshot', 'extension', 'open']);
+    const aspects = (mode) =>
+      describeAttachDifferences(mode).map(({ aspect }) => aspect);
+    assert.ok(aspects('snapshot').includes('not-copied'));
+    assert.ok(aspects('snapshot').includes('encrypted-data'));
+    assert.ok(aspects('extension').includes('debugger-infobar'));
+    assert.ok(aspects('clean').includes('user-data-dir'));
+    assert.deepEqual(describeAttachDifferences('open'), []);
+    for (const mode of ATTACH_MODES) {
+      for (const entry of describeAttachDifferences(mode)) {
+        assert.equal(typeof entry.description, 'string');
+      }
+    }
+    // Callers get their own copies.
+    describeAttachDifferences('snapshot')[0].aspect = 'changed';
+    assert.notEqual(describeAttachDifferences('snapshot')[0].aspect, 'changed');
+    assert.throws(() => describeAttachDifferences('remote'), TypeError);
+  });
+
+  it('is exported from the package API', () => {
+    for (const name of [
+      'attachUserBrowser',
+      'attachViaExtension',
+      'describeAttachDifferences',
+      'snapshotUserDataDir',
+    ]) {
+      assert.equal(typeof publicApi[name], 'function', name);
+    }
+    assert.equal(publicApi.DEFAULT_RELAY_PORT, 9333);
+    assert.equal(publicApi.RELAY_PATH, '/browser-commander');
+  });
+});
+
+describe('snapshot attach launch option', () => {
+  it('maps channels to the browser whose profile is copied', () => {
+    assert.equal(snapshotBrowserForChannel('chrome'), 'chrome');
+    assert.equal(snapshotBrowserForChannel('chrome-beta'), 'chrome');
+    assert.equal(snapshotBrowserForChannel('msedge-dev'), 'edge');
+    assert.equal(snapshotBrowserForChannel('brave'), 'brave');
+    assert.equal(snapshotBrowserForChannel('chromium'), 'chromium');
+  });
+
+  it('rejects attach with userDataDir, migrateFrom, other modes and --profile-directory', () => {
+    const attach = { mode: 'snapshot' };
+    validateAttachOption({ attach });
+    validateAttachOption({ attach: undefined, userDataDir: '/tmp/x' });
+    for (const options of [
+      { attach, userDataDir: '/tmp/x' },
+      { attach, migrateFrom: { browser: 'chrome' } },
+      { attach: { mode: 'extension' } },
+      { attach: 'snapshot' },
+      { attach, customArgs: ['--profile-directory=Profile 1'] },
+    ]) {
+      assert.throws(() => validateAttachOption(options), TypeError);
+    }
+  });
+
+  it('rejects attach and userDataDir before anything touches the disk', async () => {
+    const calls = [];
+    const { dependencies } = fakeLaunchDependencies(calls);
+    for (const options of [
+      { attach: { mode: 'snapshot' }, userDataDir: '/tmp/dedicated' },
+      { attach: { mode: 'snapshot' }, migrateFrom: { browser: 'chrome' } },
+      { attach: { mode: 'open' } },
+    ]) {
+      await assert.rejects(
+        launchAndConnectRealBrowserWithDependencies(options, {
+          ...dependencies,
+          snapshotUserDataDir: fakeSnapshot(calls),
+        }),
+        TypeError
+      );
+    }
+    assert.deepEqual(calls, []);
+    await assert.rejects(
+      launchBrowserWithDependencies({
+        launch: 'engine',
+        attach: { mode: 'snapshot' },
+      }),
+      /attach needs launch: 'real'/u
+    );
+  });
+
+  it('launches on the snapshot with --profile-directory and deletes it on exit', async () => {
+    const calls = [];
+    const snapshots = [];
+    const { browserProcess, dependencies } = fakeLaunchDependencies(calls);
+
+    const result = await launchAndConnectRealBrowserWithDependencies(
+      {
+        engine: 'puppeteer',
+        channel: 'msedge',
+        attach: { mode: 'snapshot', profile: 'Profile 1' },
+        args: ['--lang=en-US'],
+      },
+      { ...dependencies, snapshotUserDataDir: fakeSnapshot(snapshots) }
+    );
+
+    assert.deepEqual(snapshots, [
+      { browser: 'edge', profile: 'Profile 1', userDataDir: undefined },
+    ]);
+    assert.equal(result.temporaryProfile, true);
+    assert.equal(result.userDataDir, result.attach.snapshot.target);
+    assert.equal(result.attach.mode, 'snapshot');
+    assert.deepEqual(
+      result.attach.differences,
+      describeAttachDifferences('snapshot')
+    );
+    assert.deepEqual(calls[0], [
+      'spawn',
+      [
+        `--user-data-dir=${result.userDataDir}`,
+        '--remote-debugging-port=9555',
+        '--profile-directory=Profile 1',
+        '--lang=en-US',
+        'about:blank',
+      ],
+    ]);
+
+    await access(result.userDataDir);
+    browserProcess.exit(0);
+    await new Promise((resolve) => setTimeout(resolve, 50));
+    await assert.rejects(access(result.userDataDir), { code: 'ENOENT' });
+  });
+
+  it('warns when the keystore is bypassed or the browsers differ', async () => {
+    const calls = [];
+    const launch = await prepareSnapshotLaunch({
+      attach: { mode: 'snapshot', browser: 'chrome' },
+      channel: 'brave',
+      restrictions: [],
+      customArgs: [
+        '--use-mock-keychain',
+        '--password-store=basic',
+        '--password-store=detect',
+      ],
+      snapshot: fakeSnapshot(calls, {
+        warnings: [{ item: 'Local State', reason: 'local-state-missing' }],
+      }),
+    });
+
+    assert.deepEqual(launch.args, []);
+    assert.deepEqual(
+      launch.attach.snapshot.warnings.map(({ item, reason }) => [item, reason]),
+      [
+        ['Local State', 'local-state-missing'],
+        ['--use-mock-keychain', 'encrypted-data-unreadable'],
+        ['--password-store=basic', 'encrypted-data-unreadable'],
+        ['brave', 'browser-mismatch'],
+      ]
+    );
+    assert.equal(calls[0].profile, 'Default');
+  });
+});
+
+describe('attachUserBrowser', () => {
+  it('dispatches each mode to its implementation', async () => {
+    const seen = [];
+    const dependencies = {
+      launchRealBrowser: async (options) => {
+        seen.push(['launch', options]);
+        return { page: 'page', attach: { mode: 'snapshot' } };
+      },
+      attachViaExtension: async (options) => {
+        seen.push(['extension', options]);
+        return { mode: 'extension' };
+      },
+      openInUserBrowser: async (url, options) => {
+        seen.push(['open', url, options]);
+        return { opened: url, command: ['xdg-open', url] };
+      },
+    };
+
+    const snapshot = await attachUserBrowser(
+      { mode: 'snapshot', browser: 'chrome', profile: 'P', headless: true },
+      dependencies
+    );
+    assert.equal(snapshot.page, 'page');
+    assert.equal(snapshot.mode, 'snapshot');
+    assert.ok(snapshot.differences.length > 0);
+    assert.deepEqual(
+      await attachUserBrowser({ mode: 'extension', port: 1 }, dependencies),
+      { mode: 'extension' }
+    );
+    assert.deepEqual(
+      await attachUserBrowser(
+        { mode: 'open', url: 'https://a.test/' },
+        dependencies
+      ),
+      {
+        mode: 'open',
+        opened: 'https://a.test/',
+        command: ['xdg-open', 'https://a.test/'],
+        differences: [],
+      }
+    );
+    assert.deepEqual(seen, [
+      [
+        'launch',
+        {
+          headless: true,
+          attach: {
+            mode: 'snapshot',
+            browser: 'chrome',
+            profile: 'P',
+            userDataDir: undefined,
+          },
+        },
+      ],
+      ['extension', { port: 1 }],
+      ['open', 'https://a.test/', {}],
+    ]);
+    await assert.rejects(
+      attachUserBrowser({ mode: 'open' }, dependencies),
+      TypeError
+    );
+    await assert.rejects(attachUserBrowser({ mode: 'clean' }), TypeError);
+  });
+
+  it('prepares a launch from a real snapshot of a directory', async () => {
+    const root = await makeTempDir();
+    await mkdir(path.join(root, 'Default'));
+    await writeFile(path.join(root, 'Default', 'Preferences'), '{}');
+    const to = path.join(await makeTempDir(), 'copy');
+
+    const launch = await prepareSnapshotLaunch({
+      attach: { mode: 'snapshot', userDataDir: root },
+      channel: 'chrome',
+      restrictions: [],
+      customArgs: [],
+      snapshot: (options) => snapshotUserDataDir({ ...options, to }),
+    });
+
+    assert.equal(launch.userDataDir, to);
+    assert.equal(launch.attach.snapshot.source.userDataDir, root);
+    await access(path.join(to, 'Default', 'Preferences'));
+  });
+});

package/tests/unit/browser/attach/snapshot.test.js

@@ -0,0 +1,390 @@
+// feature-parity: attach.snapshot
+import assert from 'node:assert';
+import { createHash } from 'node:crypto';
+import {
+  chmod,
+  mkdir,
+  readdir,
+  readFile,
+  stat,
+  symlink,
+  writeFile,
+} from 'node:fs/promises';
+import path from 'node:path';
+import { describe, it } from 'node:test';
+
+import BetterSqlite3 from 'better-sqlite3';
+
+import {
+  isSqliteFile,
+  snapshotSkipReason,
+  snapshotUserDataDir,
+} from '../../../../src/browser/attach/snapshot.js';
+import { removeUserDataDir } from '../../../../src/browser/profile-directory.js';
+import {
+  readProfileJson,
+  writeChromiumHistory,
+  writeProfileJson,
+} from '../../../helpers/migration-fixtures.js';
+import { useTempDirectories } from '../../../helpers/temp-directory.js';
+
+const makeTempDir = useTempDirectories('bc-attach-snapshot-');
+
+function snapshotChrome(root, to) {
+  return snapshotUserDataDir({ browser: 'chrome', userDataDir: root, to });
+}
+
+/** Write `content` to `root/relativePath`, creating the parent folders. */
+async function put(root, relativePath, content = relativePath) {
+  const filePath = path.join(root, ...relativePath.split('/'));
+  await mkdir(path.dirname(filePath), { recursive: true });
+  await writeFile(filePath, content);
+  return filePath;
+}
+
+/**
+ * A Chromium user data directory with one `Default` profile holding a mix of
+ * data, caches, locks and session files, plus a second profile.
+ */
+async function makeUserDataDir() {
+  const root = await makeTempDir();
+  await put(root, 'Local State', JSON.stringify({ os_crypt: { key: 'k' } }));
+  await put(root, 'SingletonLock');
+  const profile = path.join(root, 'Default');
+  await mkdir(profile);
+  await writeProfileJson(profile, 'Preferences', {
+    profile: { name: 'Person 1', exit_type: 'Crashed', exited_cleanly: false },
+  });
+  await writeProfileJson(profile, 'Bookmarks', { roots: {} });
+  writeChromiumHistory(profile, 3);
+  for (const item of [
+    'LOCK',
+    'Cache/Cache_Data/data_0',
+    'Code Cache/js/index',
+    'GPUCache/data_1',
+    'Service Worker/CacheStorage/abc/index',
+    'Service Worker/Database/000003.log',
+    'Sessions/Session_1',
+    'Current Session',
+    'Local Storage/leveldb/000003.log',
+    'Local Storage/leveldb/LOCK',
+    'Cookies-journal',
+  ]) {
+    await put(profile, item);
+  }
+  await put(root, 'Profile 1/Preferences', '{}');
+  return root;
+}
+
+/** Hash, size and mtime of every file under a directory. */
+async function fingerprintTree(root) {
+  const entries = await readdir(root, { recursive: true, withFileTypes: true });
+  const result = {};
+  for (const entry of entries) {
+    if (!entry.isFile()) {
+      continue;
+    }
+    const filePath = path.join(entry.parentPath ?? entry.path, entry.name);
+    const { mtimeMs, size } = await stat(filePath);
+    const hash = createHash('sha256')
+      .update(await readFile(filePath))
+      .digest('hex');
+    result[path.relative(root, filePath)] = { hash, mtimeMs, size };
+  }
+  return result;
+}
+
+function countRows(databasePath) {
+  const database = new BetterSqlite3(databasePath, {
+    readonly: true,
+    fileMustExist: true,
+  });
+  try {
+    return database.prepare('SELECT COUNT(*) AS c FROM urls').get().c;
+  } finally {
+    database.close();
+  }
+}
+
+describe('snapshotSkipReason', () => {
+  it('names why locks, caches, crash reports, sessions and sidecars are skipped', () => {
+    const cases = {
+      SingletonLock: 'lock',
+      SingletonSocket: 'lock',
+      'Default/LOCK': 'lock',
+      'Default/lockfile': 'lock',
+      'Default/Cache': 'cache',
+      'Default/Code Cache': 'cache',
+      'Default/GPUCache': 'cache',
+      'Default/DawnGraphiteCache': 'cache',
+      'Default/Service Worker/CacheStorage': 'cache',
+      Crashpad: 'crash-reports',
+      'Default/Sessions': 'session',
+      'Default/Current Tabs': 'session',
+      'Default/Last Session': 'session',
+      'Default/History-journal': 'sqlite-sidecar',
+      'Default/Cookies-wal': 'sqlite-sidecar',
+      'Default/Cookies-shm': 'sqlite-sidecar',
+      'Default/History': null,
+      'Default/Preferences': null,
+      'Default/Service Worker/Database': null,
+      'Default/Local Storage/leveldb/000003.log': null,
+    };
+    for (const [relativePath, reason] of Object.entries(cases)) {
+      assert.equal(snapshotSkipReason(relativePath), reason, relativePath);
+    }
+  });
+});
+
+describe('snapshotUserDataDir', () => {
+  it('copies Local State and the one profile, skipping locks and caches', async () => {
+    const root = await makeUserDataDir();
+    const to = path.join(await makeTempDir(), 'copy');
+
+    const report = await snapshotChrome(root, to);
+
+    assert.deepEqual(report.source, {
+      browser: 'chrome',
+      profile: 'Default',
+      userDataDir: root,
+    });
+    assert.equal(report.target, to);
+    assert.deepEqual(report.warnings, []);
+    assert.equal(report.copied.databases, 1);
+    assert.equal(
+      await readFile(path.join(to, 'Local State'), 'utf8'),
+      JSON.stringify({ os_crypt: { key: 'k' } })
+    );
+    assert.deepEqual(
+      await readProfileJson(path.join(to, 'Default'), 'Bookmarks'),
+      {
+        roots: {},
+      }
+    );
+    assert.equal(countRows(path.join(to, 'Default', 'History')), 3);
+    assert.equal(await isSqliteFile(path.join(to, 'Default', 'History')), true);
+    for (const kept of [
+      'Default/Service Worker/Database/000003.log',
+      'Default/Local Storage/leveldb/000003.log',
+      'First Run',
+    ]) {
+      await stat(path.join(to, kept));
+    }
+
+    const skipped = Object.fromEntries(
+      report.skipped.map(({ item, reason }) => [item, reason])
+    );
+    assert.deepEqual(skipped, {
+      'Default/Cache': 'cache',
+      'Default/Code Cache': 'cache',
+      'Default/Cookies-journal': 'sqlite-sidecar',
+      'Default/Current Session': 'session',
+      'Default/GPUCache': 'cache',
+      'Default/LOCK': 'lock',
+      'Default/Local Storage/leveldb/LOCK': 'lock',
+      'Default/Service Worker/CacheStorage': 'cache',
+      'Default/Sessions': 'session',
+    });
+    for (const absent of [
+      'SingletonLock',
+      'Profile 1',
+      'Default/Cache',
+      'Default/Sessions',
+      'Default/LOCK',
+      'Default/Cookies-journal',
+    ]) {
+      await assert.rejects(stat(path.join(to, absent)), { code: 'ENOENT' });
+    }
+  });
+
+  it('never modifies the source', async () => {
+    const root = await makeUserDataDir();
+    const before = await fingerprintTree(root);
+
+    const report = await snapshotUserDataDir({
+      browser: 'chrome',
+      userDataDir: root,
+      to: path.join(await makeTempDir(), 'copy'),
+    });
+
+    assert.deepEqual(await fingerprintTree(root), before);
+    assert.ok(report.copied.files > 0);
+  });
+
+  it('marks only the copy as cleanly exited', async () => {
+    const root = await makeUserDataDir();
+    const to = path.join(await makeTempDir(), 'copy');
+
+    await snapshotUserDataDir({ browser: 'edge', userDataDir: root, to });
+
+    assert.deepEqual(
+      (await readProfileJson(path.join(to, 'Default'), 'Preferences')).profile,
+      { name: 'Person 1', exit_type: 'Normal', exited_cleanly: true }
+    );
+    assert.equal(
+      (await readProfileJson(path.join(root, 'Default'), 'Preferences')).profile
+        .exit_type,
+      'Crashed'
+    );
+  });
+
+  for (const journalMode of ['wal', 'delete']) {
+    it(`snapshots a ${journalMode}-mode database while a write transaction holds it`, async () => {
+      const root = await makeTempDir();
+      const profile = path.join(root, 'Default');
+      await mkdir(profile);
+      const historyPath = writeChromiumHistory(profile, 5);
+      const live = new BetterSqlite3(historyPath);
+      try {
+        live.pragma(`journal_mode = ${journalMode}`);
+        // Keep committed rows in the WAL, as a running Chrome does.
+        live.pragma('wal_autocheckpoint = 0');
+        const insert = live.prepare('INSERT INTO urls (url) VALUES (?)');
+        insert.run('https://committed.test/');
+        live.exec('BEGIN IMMEDIATE');
+        for (let index = 0; index < 50; index += 1) {
+          insert.run(`https://uncommitted.test/${index}`);
+        }
+        const sourceFiles = [
+          'History',
+          `History-${journalMode === 'wal' ? 'wal' : 'journal'}`,
+        ];
+        const before = await Promise.all(
+          sourceFiles.map((name) => readFile(path.join(profile, name)))
+        );
+        const to = path.join(await makeTempDir(), 'copy');
+
+        const report = await snapshotChrome(root, to);
+
+        const copy = path.join(to, 'Default', 'History');
+        // One self-contained file: the committed WAL content is folded in.
+        assert.deepEqual(await readdir(path.join(to, 'Default')), ['History']);
+        assert.equal(report.copied.databases, 1);
+        assert.equal(countRows(copy), 6);
+        const database = new BetterSqlite3(copy, { readonly: true });
+        try {
+          assert.equal(
+            database.pragma('integrity_check', { simple: true }),
+            'ok'
+          );
+        } finally {
+          database.close();
+        }
+        assert.ok(
+          report.skipped.every(({ reason }) => reason === 'sqlite-sidecar'),
+          JSON.stringify(report.skipped)
+        );
+        const after = await Promise.all(
+          sourceFiles.map((name) => readFile(path.join(profile, name)))
+        );
+        assert.deepEqual(after, before);
+      } finally {
+        if (live.inTransaction) {
+          live.exec('ROLLBACK');
+        }
+        live.close();
+      }
+    });
+  }
+
+  it(
+    'reports symlinks and unreadable entries instead of failing',
+    {
+      skip:
+        process.platform === 'win32' && 'symlinks and modes differ on Windows',
+    },
+    async () => {
+      const root = await makeTempDir();
+      const profile = path.join(root, 'Default');
+      await put(profile, 'Preferences', '{}');
+      const secret = await put(profile, 'Secret');
+      await symlink(path.join(root, 'elsewhere'), path.join(profile, 'Link'));
+      const runsAsRoot = process.getuid?.() === 0;
+      await chmod(secret, 0o000);
+      const to = path.join(await makeTempDir(), 'copy');
+
+      try {
+        const report = await snapshotUserDataDir({
+          browser: 'chrome',
+          userDataDir: root,
+          to,
+        });
+        const reasons = Object.fromEntries(
+          report.skipped.map(({ item, reason }) => [item, reason])
+        );
+        assert.equal(reasons['Default/Link'], 'symlink');
+        if (!runsAsRoot) {
+          assert.equal(reasons['Default/Secret'], 'unreadable');
+        }
+        assert.equal(report.warnings[0].reason, 'local-state-missing');
+      } finally {
+        await chmod(secret, 0o600);
+      }
+    }
+  );
+
+  it('creates a temporary target when none is given', async () => {
+    const root = await makeUserDataDir();
+
+    const report = await snapshotUserDataDir({
+      browser: 'chrome',
+      profile: 'Profile 1',
+      userDataDir: root,
+    });
+
+    try {
+      assert.equal(report.source.profile, 'Profile 1');
+      await stat(path.join(report.target, 'Profile 1', 'Preferences'));
+      await assert.rejects(stat(path.join(report.target, 'Default')), {
+        code: 'ENOENT',
+      });
+    } finally {
+      await removeUserDataDir(report.target);
+    }
+  });
+
+  it('rejects Firefox, bad profile names and missing profiles', async () => {
+    const root = await makeUserDataDir();
+
+    await assert.rejects(
+      snapshotUserDataDir({ browser: 'firefox', userDataDir: root }),
+      /only supported for Chromium-family browsers/u
+    );
+    await assert.rejects(snapshotUserDataDir({}), TypeError);
+    for (const profile of ['', '..', 'a/b', 'a\\b']) {
+      await assert.rejects(
+        snapshotUserDataDir({ browser: 'chrome', profile, userDataDir: root }),
+        TypeError,
+        profile
+      );
+    }
+    await assert.rejects(
+      snapshotUserDataDir({
+        browser: 'chrome',
+        profile: 'Profile 9',
+        userDataDir: root,
+      }),
+      /No chrome profile "Profile 9"/u
+    );
+  });
+
+  it('refuses a non-empty target and a target inside the source', async () => {
+    const root = await makeUserDataDir();
+    const busy = await makeTempDir();
+    await put(busy, 'something');
+
+    await assert.rejects(
+      snapshotUserDataDir({ browser: 'chrome', userDataDir: root, to: busy }),
+      /is not empty/u
+    );
+    await assert.rejects(
+      snapshotUserDataDir({
+        browser: 'chrome',
+        userDataDir: root,
+        to: path.join(root, 'copy'),
+      }),
+      /inside the source/u
+    );
+    await assert.rejects(stat(path.join(root, 'copy')), { code: 'ENOENT' });
+  });
+});