lighthouse 9.6.8 → 10.0.0-dev.20230209

package/cli/test/smokehouse/lib/concurrent-mapper.js

@@ -0,0 +1,125 @@
+/**
+ * @license Copyright 2019 The Lighthouse Authors. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+ */
+
+/**
+ * A class that maintains a concurrency pool to coordinate many jobs that should
+ * only be run `concurrencyLimit` at a time.
+ * API inspired by http://bluebirdjs.com/docs/api/promise.map.html, but
+ * independent callers of `concurrentMap()` share the same concurrency limit.
+ */
+class ConcurrentMapper {
+  constructor() {
+    /** @type {Set<Promise<unknown>>} */
+    this._promisePool = new Set();
+
+    /**
+     * The limits of all currently running jobs. There will be duplicates.
+     * @type {Array<number>}
+     */
+    this._allConcurrencyLimits = [];
+  }
+
+  /**
+   * Runs callbackfn on `values` in parallel, at a max of `concurrency` at a
+   * time. Resolves to an array of the results or rejects with the first
+   * rejected result. Default `concurrency` limit is `Infinity`.
+   * @template T, U
+   * @param {Array<T>} values
+   * @param {(value: T, index: number, array: Array<T>) => Promise<U>} callbackfn
+   * @param {{concurrency: number}} [options]
+   * @return {Promise<Array<U>>}
+   */
+  static async map(values, callbackfn, options) {
+    const cm = new ConcurrentMapper();
+    return cm.pooledMap(values, callbackfn, options);
+  }
+
+  /**
+   * Returns whether there are fewer running jobs than the minimum current
+   * concurrency limit and the proposed new `concurrencyLimit`.
+   * @param {number} concurrencyLimit
+   */
+  _canRunMoreAtLimit(concurrencyLimit) {
+    return this._promisePool.size < concurrencyLimit &&
+        this._promisePool.size < Math.min(...this._allConcurrencyLimits);
+  }
+
+  /**
+   * Add a job to pool.
+   * @param {Promise<unknown>} job
+   * @param {number} concurrencyLimit
+   */
+  _addJob(job, concurrencyLimit) {
+    this._promisePool.add(job);
+    this._allConcurrencyLimits.push(concurrencyLimit);
+  }
+
+  /**
+   * Remove a job from pool.
+   * @param {Promise<unknown>} job
+   * @param {number} concurrencyLimit
+   */
+  _removeJob(job, concurrencyLimit) {
+    this._promisePool.delete(job);
+
+    const limitIndex = this._allConcurrencyLimits.indexOf(concurrencyLimit);
+    if (limitIndex === -1) {
+      throw new Error('No current limit found for finishing job');
+    }
+    this._allConcurrencyLimits.splice(limitIndex, 1);
+  }
+
+  /**
+   * Runs callbackfn on `values` in parallel, at a max of `concurrency` at
+   * a time across all callers on this instance. Resolves to an array of the
+   * results (for each caller separately) or rejects with the first rejected
+   * result. Default `concurrency` limit is `Infinity`.
+   * @template T, U
+   * @param {Array<T>} values
+   * @param {(value: T, index: number, array: Array<T>) => Promise<U>} callbackfn
+   * @param {{concurrency: number}} [options]
+   * @return {Promise<Array<U>>}
+   */
+  async pooledMap(values, callbackfn, options = {concurrency: Infinity}) {
+    const {concurrency} = options;
+    const result = [];
+
+    for (let i = 0; i < values.length; i++) {
+      // Wait until concurrency allows another run.
+      while (!this._canRunMoreAtLimit(concurrency)) {
+        // Unconditionally catch since we only care about our own failures
+        // (caught in the Promise.all below), not other callers.
+        await Promise.race(this._promisePool).catch(() => {});
+      }
+
+      // innerPromise removes itself from the pool and resolves on return from callback.
+      const innerPromise = callbackfn(values[i], i, values)
+        .finally(() => this._removeJob(innerPromise, concurrency));
+
+      this._addJob(innerPromise, concurrency);
+      result.push(innerPromise);
+    }
+
+    return Promise.all(result);
+  }
+
+  /**
+   * Runs `fn` concurrent to other operations in the pool, at a max of
+   * `concurrency` at a time across all callers on this instance. Default
+   * `concurrency` limit is `Infinity`.
+   * @template U
+   * @param {() => Promise<U>} fn
+   * @param {{concurrency: number}} [options]
+   * @return {Promise<U>}
+   */
+  async runInPool(fn, options = {concurrency: Infinity}) {
+    // Let pooledMap handle the pool management for the cost of boxing a fake `value`.
+    const result = await this.pooledMap([''], fn, options);
+    return result[0];
+  }
+}
+
+export {ConcurrentMapper};

package/cli/test/smokehouse/lib/local-console.d.ts

@@ -0,0 +1,33 @@
+/**
+ * @license Copyright 2019 The Lighthouse Authors. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+ */
+/**
+ * A simple buffered log to use in place of `console`.
+ */
+export class LocalConsole {
+    _log: string;
+    /**
+     * @param {string} str
+     */
+    log(str: string): void;
+    /**
+     * Log but without the ending newline.
+     * @param {string} str
+     */
+    write(str: string): void;
+    /**
+     * @return {string}
+     */
+    getLog(): string;
+    /**
+     * Append a stdout and stderr to this log.
+     * @param {{stdout: string, stderr: string}} stdStrings
+     */
+    adoptStdStrings(stdStrings: {
+        stdout: string;
+        stderr: string;
+    }): void;
+}
+//# sourceMappingURL=local-console.d.ts.map

package/cli/test/smokehouse/lib/local-console.js

@@ -0,0 +1,50 @@
+/**
+ * @license Copyright 2019 The Lighthouse Authors. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+ */
+
+/**
+ * A simple buffered log to use in place of `console`.
+ */
+class LocalConsole {
+  constructor() {
+    this._log = '';
+  }
+
+  /**
+   * @param {string} str
+   */
+  log(str) {
+    this._log += str + '\n';
+  }
+
+  /**
+   * Log but without the ending newline.
+   * @param {string} str
+   */
+  write(str) {
+    this._log += str;
+  }
+
+  /**
+   * @return {string}
+   */
+  getLog() {
+    return this._log;
+  }
+
+  /**
+   * Append a stdout and stderr to this log.
+   * @param {{stdout: string, stderr: string}} stdStrings
+   */
+  adoptStdStrings(stdStrings) {
+    this.write(stdStrings.stdout);
+    // stderr accrues many empty lines. Don't log unless there's content.
+    if (/\S/.test(stdStrings.stderr)) {
+      this.write(stdStrings.stderr);
+    }
+  }
+}
+
+export {LocalConsole};

package/cli/test/smokehouse/lighthouse-runners/bundle.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Launch Chrome and do a full Lighthouse run via the Lighthouse DevTools bundle.
+ * @param {string} url
+ * @param {LH.Config=} config
+ * @param {{isDebug?: boolean, useLegacyNavigation?: boolean}=} testRunnerOptions
+ * @return {Promise<{lhr: LH.Result, artifacts: LH.Artifacts, log: string}>}
+ */
+export function runLighthouse(url: string, config?: LH.Config | undefined, testRunnerOptions?: {
+    isDebug?: boolean;
+    useLegacyNavigation?: boolean;
+} | undefined): Promise<{
+    lhr: LH.Result;
+    artifacts: LH.Artifacts;
+    log: string;
+}>;
+//# sourceMappingURL=bundle.d.ts.map

package/cli/test/smokehouse/lighthouse-runners/bundle.js

@@ -0,0 +1,158 @@
+/**
+ * @license Copyright 2019 The Lighthouse Authors. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+ */
+
+/**
+ * @fileoverview  A runner that launches Chrome and executes Lighthouse via a
+ * bundle to test that bundling has produced correct and runnable code.
+ * Currently uses `lighthouse-dt-bundle.js`.
+ * Runs in a worker to avoid messing up marky's global state.
+ */
+
+import fs from 'fs';
+import os from 'os';
+import {Worker, isMainThread, parentPort, workerData} from 'worker_threads';
+import {once} from 'events';
+
+import puppeteer from 'puppeteer-core';
+import ChromeLauncher from 'chrome-launcher';
+
+import {CriConnection} from '../../../../core/legacy/gather/connections/cri.js';
+import {LH_ROOT} from '../../../../root.js';
+import {loadArtifacts, saveArtifacts} from '../../../../core/lib/asset-saver.js';
+
+// This runs only in the worker. The rest runs on the main thread.
+if (!isMainThread && parentPort) {
+  (async () => {
+    const {url, config, testRunnerOptions} = workerData;
+    try {
+      const result = await runBundledLighthouse(url, config, testRunnerOptions);
+      // Save to assets directory because LighthouseError won't survive postMessage.
+      const assetsDir = fs.mkdtempSync(os.tmpdir() + '/smoke-bundle-assets-');
+      await saveArtifacts(result.artifacts, assetsDir);
+      const value = {
+        lhr: result.lhr,
+        assetsDir,
+      };
+      parentPort?.postMessage({type: 'result', value});
+    } catch (err) {
+      console.error(err);
+      parentPort?.postMessage({type: 'error', value: err});
+    }
+  })();
+}
+
+/**
+ * @param {string} url
+ * @param {LH.Config|undefined} config
+ * @param {{isDebug?: boolean, useLegacyNavigation?: boolean}} testRunnerOptions
+ * @return {Promise<{lhr: LH.Result, artifacts: LH.Artifacts}>}
+ */
+async function runBundledLighthouse(url, config, testRunnerOptions) {
+  if (isMainThread || !parentPort) {
+    throw new Error('must be called in worker');
+  }
+
+  const originalBuffer = global.Buffer;
+  const originalRequire = global.require;
+  if (typeof globalThis === 'undefined') {
+    // @ts-expect-error - exposing for loading of dt-bundle.
+    global.globalThis = global;
+  }
+
+  // Load bundle, which creates a `global.runBundledLighthouse`.
+  eval(fs.readFileSync(LH_ROOT + '/dist/lighthouse-dt-bundle.js', 'utf-8'));
+
+  global.require = originalRequire;
+  global.Buffer = originalBuffer;
+
+  /** @type {import('../../../../core/index.js')['default']} */
+  // @ts-expect-error - not worth giving test global an actual type.
+  const lighthouse = global.runBundledLighthouse;
+
+  /** @type {import('../../../../core/index.js')['legacyNavigation']} */
+  // @ts-expect-error - not worth giving test global an actual type.
+  const legacyNavigation = global.runBundledLighthouseLegacyNavigation;
+
+  // Launch and connect to Chrome.
+  const launchedChrome = await ChromeLauncher.launch();
+  const port = launchedChrome.port;
+
+  // Run Lighthouse.
+  try {
+    const logLevel = testRunnerOptions.isDebug ? 'info' : undefined;
+    let runnerResult;
+    if (testRunnerOptions.useLegacyNavigation) {
+      const connection = new CriConnection(port);
+      runnerResult =
+        await legacyNavigation(url, {port, logLevel}, config, connection);
+    } else {
+      // Puppeteer is not included in the bundle, we must create the page here.
+      const browser = await puppeteer.connect({browserURL: `http://localhost:${port}`});
+      const page = await browser.newPage();
+      runnerResult = await lighthouse(url, {port, logLevel}, config, page);
+    }
+    if (!runnerResult) throw new Error('No runnerResult');
+
+    return {
+      lhr: runnerResult.lhr,
+      artifacts: runnerResult.artifacts,
+    };
+  } finally {
+    // Clean up and return results.
+    await launchedChrome.kill();
+  }
+}
+
+/**
+ * Launch Chrome and do a full Lighthouse run via the Lighthouse DevTools bundle.
+ * @param {string} url
+ * @param {LH.Config=} config
+ * @param {{isDebug?: boolean, useLegacyNavigation?: boolean}=} testRunnerOptions
+ * @return {Promise<{lhr: LH.Result, artifacts: LH.Artifacts, log: string}>}
+ */
+async function runLighthouse(url, config, testRunnerOptions = {}) {
+  /** @type {string[]} */
+  const logs = [];
+  const worker = new Worker(new URL(import.meta.url), {
+    stdout: true,
+    stderr: true,
+    workerData: {url, config, testRunnerOptions},
+  });
+  worker.stdout.setEncoding('utf8');
+  worker.stderr.setEncoding('utf8');
+  worker.stdout.addListener('data', (data) => {
+    process.stdout.write(data);
+    logs.push(`STDOUT: ${data}`);
+  });
+  worker.stderr.addListener('data', (data) => {
+    process.stderr.write(data);
+    logs.push(`STDERR: ${data}`);
+  });
+  const [workerResponse] = await once(worker, 'message');
+  const log = logs.join('') + '\n';
+
+  if (workerResponse.type === 'error') {
+    new Error(`Worker returned an error: ${workerResponse.value}\nLog:\n${log}`);
+  }
+
+  const result = workerResponse.value;
+  if (!result.lhr || !result.assetsDir) {
+    throw new Error(`invalid response from worker:\n${JSON.stringify(result, null, 2)}`);
+  }
+
+  const artifacts = loadArtifacts(result.assetsDir);
+  fs.rmSync(result.assetsDir, {recursive: true});
+
+  return {
+    lhr: result.lhr,
+    artifacts,
+    log,
+  };
+}
+
+export {
+  runLighthouse,
+};

package/cli/test/smokehouse/lighthouse-runners/cli.d.ts

@@ -0,0 +1,18 @@
+/// <reference path="../../../../../../types/internal/lighthouse-logger.d.ts" />
+/**
+ * Launch Chrome and do a full Lighthouse run via the Lighthouse CLI.
+ * @param {string} url
+ * @param {LH.Config=} config
+ * @param {{isDebug?: boolean, useFraggleRock?: boolean}=} testRunnerOptions
+ * @return {Promise<{lhr: LH.Result, artifacts: LH.Artifacts, log: string}>}
+ */
+export function runLighthouse(url: string, config?: LH.Config | undefined, testRunnerOptions?: {
+    isDebug?: boolean | undefined;
+    useFraggleRock?: boolean | undefined;
+} | undefined): Promise<{
+    lhr: LH.Result;
+    artifacts: LH.Artifacts;
+    log: string;
+}>;
+import log from "lighthouse-logger";
+//# sourceMappingURL=cli.d.ts.map

package/cli/test/smokehouse/lighthouse-runners/cli.js

@@ -0,0 +1,134 @@
+/**
+ * @license Copyright 2019 The Lighthouse Authors. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+ */
+
+/**
+ * @fileoverview  A runner that executes Lighthouse via the Lighthouse CLI to
+ * test the full pipeline, from parsing arguments on the command line to writing
+ * results to disk. When complete, reads back the artifacts and LHR and returns
+ * them.
+ */
+
+import {promises as fs} from 'fs';
+import {promisify} from 'util';
+import {execFile} from 'child_process';
+
+import log from 'lighthouse-logger';
+
+import * as assetSaver from '../../../../core/lib/asset-saver.js';
+import {LocalConsole} from '../lib/local-console.js';
+import {ChildProcessError} from '../lib/child-process-error.js';
+import {LH_ROOT} from '../../../../root.js';
+
+const execFileAsync = promisify(execFile);
+
+/**
+ * Launch Chrome and do a full Lighthouse run via the Lighthouse CLI.
+ * @param {string} url
+ * @param {LH.Config=} config
+ * @param {{isDebug?: boolean, useFraggleRock?: boolean}=} testRunnerOptions
+ * @return {Promise<{lhr: LH.Result, artifacts: LH.Artifacts, log: string}>}
+ */
+async function runLighthouse(url, config, testRunnerOptions = {}) {
+  const {isDebug} = testRunnerOptions;
+  const tmpDir = `${LH_ROOT}/.tmp/smokehouse`;
+  await fs.mkdir(tmpDir, {recursive: true});
+  const tmpPath = await fs.mkdtemp(`${tmpDir}/smokehouse-`);
+  return internalRun(url, tmpPath, config, testRunnerOptions)
+    // Wait for internalRun() before removing scratch directory.
+    .finally(() => !isDebug && fs.rm(tmpPath, {recursive: true, force: true}));
+}
+
+/**
+ * Internal runner.
+ * @param {string} url
+ * @param {string} tmpPath
+ * @param {LH.Config=} config
+ * @param {{isDebug?: boolean, useLegacyNavigation?: boolean}=} options
+ * @return {Promise<{lhr: LH.Result, artifacts: LH.Artifacts, log: string}>}
+ */
+async function internalRun(url, tmpPath, config, options) {
+  const {isDebug = false, useLegacyNavigation = false} = options || {};
+  const localConsole = new LocalConsole();
+
+  const outputPath = `${tmpPath}/smokehouse.report.json`;
+  const artifactsDirectory = `${tmpPath}/artifacts/`;
+
+  const args = [
+    `${LH_ROOT}/cli/index.js`,
+    `${url}`,
+    `--output-path=${outputPath}`,
+    '--output=json',
+    `-G=${artifactsDirectory}`,
+    `-A=${artifactsDirectory}`,
+    '--port=0',
+    '--quiet',
+  ];
+
+  if (useLegacyNavigation) {
+    args.push('--legacy-navigation');
+  }
+
+  // Config can be optionally provided.
+  if (config) {
+    const configPath = `${tmpPath}/config.json`;
+    await fs.writeFile(configPath, JSON.stringify(config));
+    args.push(`--config-path=${configPath}`);
+  }
+
+  const command = 'node';
+  const env = {...process.env, NODE_ENV: 'test'};
+  localConsole.log(`${log.dim}$ ${command} ${args.join(' ')} ${log.reset}`);
+
+  /** @type {{stdout: string, stderr: string, code?: number}} */
+  let execResult;
+  try {
+    execResult = await execFileAsync(command, args, {env});
+  } catch (e) {
+    // exec-thrown errors have stdout, stderr, and exit code from child process.
+    execResult = e;
+  }
+
+  const exitCode = execResult.code || 0;
+  if (isDebug) {
+    localConsole.log(`exit code ${exitCode}`);
+    localConsole.log(`STDOUT: ${execResult.stdout}`);
+    localConsole.log(`STDERR: ${execResult.stderr}`);
+  }
+
+  try {
+    await fs.access(outputPath);
+  } catch (e) {
+    throw new ChildProcessError(`Lighthouse run failed to produce a report and exited with ${exitCode}.`, // eslint-disable-line max-len
+        localConsole.getLog());
+  }
+
+  /** @type {LH.Result} */
+  const lhr = JSON.parse(await fs.readFile(outputPath, 'utf8'));
+  const artifacts = assetSaver.loadArtifacts(artifactsDirectory);
+
+  // Output has been established as existing, so can log for debug.
+  if (isDebug) {
+    localConsole.log(`LHR output available at: ${outputPath}`);
+    localConsole.log(`Artifacts avaiable in: ${artifactsDirectory}`);
+  }
+
+  // There should either be both an error exitCode and a lhr.runtimeError or neither.
+  if (Boolean(exitCode) !== Boolean(lhr.runtimeError)) {
+    const runtimeErrorCode = lhr.runtimeError?.code;
+    throw new ChildProcessError(`Lighthouse did not exit with an error correctly, exiting with ${exitCode} but with runtimeError '${runtimeErrorCode}'`, // eslint-disable-line max-len
+        localConsole.getLog());
+  }
+
+  return {
+    lhr,
+    artifacts,
+    log: localConsole.getLog(),
+  };
+}
+
+export {
+  runLighthouse,
+};

package/cli/test/smokehouse/lighthouse-runners/devtools.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Launch Chrome and do a full Lighthouse run via DevTools.
+ * By default, the latest DevTools frontend is used (.tmp/chromium-web-tests/devtools/devtools-frontend)
+ * unless DEVTOOLS_PATH is set.
+ * CHROME_PATH determines which Chrome is used–otherwise the default is puppeteer's chrome binary.
+ * @param {string} url
+ * @param {LH.Config=} config
+ * @param {{isDebug?: boolean, useLegacyNavigation?: boolean}=} testRunnerOptions
+ * @return {Promise<{lhr: LH.Result, artifacts: LH.Artifacts, log: string}>}
+ */
+export function runLighthouse(url: string, config?: LH.Config | undefined, testRunnerOptions?: {
+    isDebug?: boolean;
+    useLegacyNavigation?: boolean;
+} | undefined): Promise<{
+    lhr: LH.Result;
+    artifacts: LH.Artifacts;
+    log: string;
+}>;
+/**
+ * Download/pull latest DevTools, build Lighthouse for DevTools, roll to DevTools, and build DevTools.
+ */
+export function setup(): Promise<void>;
+//# sourceMappingURL=devtools.d.ts.map

package/cli/test/smokehouse/lighthouse-runners/devtools.js

@@ -0,0 +1,72 @@
+/**
+ * @license Copyright 2021 The Lighthouse Authors. All Rights Reserved.
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License.
+ */
+
+/**
+ * @fileoverview A runner that launches Chrome and executes Lighthouse via DevTools.
+ */
+
+import fs from 'fs';
+import os from 'os';
+import {execFileSync} from 'child_process';
+
+import {LH_ROOT} from '../../../../root.js';
+import {testUrlFromDevtools} from '../../../../core/scripts/pptr-run-devtools.js';
+
+const devtoolsDir =
+  process.env.DEVTOOLS_PATH || `${LH_ROOT}/.tmp/chromium-web-tests/devtools/devtools-frontend`;
+
+/**
+ * Download/pull latest DevTools, build Lighthouse for DevTools, roll to DevTools, and build DevTools.
+ */
+async function setup() {
+  if (process.env.CI) return;
+
+  process.env.DEVTOOLS_PATH = devtoolsDir;
+  execFileSync('bash',
+    ['core/test/devtools-tests/download-devtools.sh'],
+    {stdio: 'inherit'}
+  );
+  execFileSync('bash',
+    ['core/test/devtools-tests/roll-devtools.sh'],
+    {stdio: 'inherit'}
+  );
+}
+
+/**
+ * Launch Chrome and do a full Lighthouse run via DevTools.
+ * By default, the latest DevTools frontend is used (.tmp/chromium-web-tests/devtools/devtools-frontend)
+ * unless DEVTOOLS_PATH is set.
+ * CHROME_PATH determines which Chrome is used–otherwise the default is puppeteer's chrome binary.
+ * @param {string} url
+ * @param {LH.Config=} config
+ * @param {{isDebug?: boolean, useLegacyNavigation?: boolean}=} testRunnerOptions
+ * @return {Promise<{lhr: LH.Result, artifacts: LH.Artifacts, log: string}>}
+ */
+async function runLighthouse(url, config, testRunnerOptions = {}) {
+  const chromeFlags = [
+    `--custom-devtools-frontend=file://${devtoolsDir}/out/LighthouseIntegration/gen/front_end`,
+  ];
+  const {lhr, artifacts, logs} = await testUrlFromDevtools(url, {
+    config,
+    chromeFlags,
+    useLegacyNavigation: testRunnerOptions.useLegacyNavigation,
+  });
+
+  if (testRunnerOptions.isDebug) {
+    const outputDir = fs.mkdtempSync(os.tmpdir() + '/lh-smoke-cdt-runner-');
+    fs.writeFileSync(`${outputDir}/lhr.json`, JSON.stringify(lhr));
+    fs.writeFileSync(`${outputDir}/artifacts.json`, JSON.stringify(artifacts));
+    console.log(`${url} results saved at ${outputDir}`);
+  }
+
+  const log = logs.join('') + '\n';
+  return {lhr, artifacts, log};
+}
+
+export {
+  runLighthouse,
+  setup,
+};