lighthouse 9.2.0-dev.20220104 → 9.2.0-dev.20220108

package/lighthouse-cli/run.js

@@ -232,6 +232,10 @@ async function runLighthouse(url, flags, config) {
   let launchedChrome;
 
   try {
+    if (url && flags.auditMode && !flags.gatherMode) {
+      log.warn('CLI', 'URL parameter is ignored if -A flag is used without -G flag');
+    }
+
     const shouldGather = flags.gatherMode || flags.gatherMode === flags.auditMode;
     const shouldUseLocalChrome = URL.isLikeLocalhost(flags.hostname);
     if (shouldGather && shouldUseLocalChrome) {

package/lighthouse-cli/test/smokehouse/frontends/smokehouse-bin.js

@@ -36,6 +36,7 @@ const coreTestDefnsPath =
 const runnerPaths = {
   cli: '../lighthouse-runners/cli.js',
   bundle: '../lighthouse-runners/bundle.js',
+  devtools: '../lighthouse-runners/devtools.js',
 };
 
 /**
@@ -151,7 +152,7 @@ async function begin() {
       },
       'runner': {
         default: 'cli',
-        choices: ['cli', 'bundle'],
+        choices: ['cli', 'bundle', 'devtools'],
         describe: 'The method of running Lighthouse',
       },
       'tests-path': {

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

@@ -0,0 +1,103 @@
+/**
+ * @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.
+ */
+'use strict';
+
+/**
+ * @fileoverview A runner that launches Chrome and executes Lighthouse via DevTools.
+ */
+
+import fs from 'fs';
+import os from 'os';
+import {spawn} from 'child_process';
+
+import {LH_ROOT} from '../../../../root.js';
+
+const devtoolsDir =
+  process.env.DEVTOOLS_PATH || `${LH_ROOT}/.tmp/chromium-web-tests/devtools/devtools-frontend`;
+
+/**
+ * @param {string} command
+ * @param {string[]} args
+ */
+async function spawnAndLog(command, args) {
+  let log = '';
+
+  /** @type {Promise<void>} */
+  const promise = new Promise((resolve, reject) => {
+    const spawnHandle = spawn(command, args);
+    spawnHandle.on('close', code => {
+      if (code === 0) resolve();
+      else reject(new Error(`Command exited with code ${code}`));
+    });
+    spawnHandle.on('error', reject);
+    spawnHandle.stdout.on('data', data => {
+      console.log(data.toString());
+      log += `STDOUT: ${data.toString()}`;
+    });
+    spawnHandle.stderr.on('data', data => {
+      console.log(data.toString());
+      log += `STDERR: ${data.toString()}`;
+    });
+  });
+  await promise;
+
+  return log;
+}
+
+/** @type {Promise<void>} */
+let buildDevtoolsPromise;
+/**
+ * Download/pull latest DevTools, build Lighthouse for DevTools, roll to DevTools, and build DevTools.
+ */
+async function buildDevtools() {
+  if (process.env.CI) return;
+
+  process.env.DEVTOOLS_PATH = devtoolsDir;
+  await spawnAndLog('bash', ['lighthouse-core/test/chromium-web-tests/download-devtools.sh']);
+  await spawnAndLog('bash', ['lighthouse-core/test/chromium-web-tests/roll-devtools.sh']);
+}
+
+/**
+ * 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.Json=} configJson
+ * @param {{isDebug?: boolean}=} testRunnerOptions
+ * @return {Promise<{lhr: LH.Result, artifacts: LH.Artifacts, log: string}>}
+ */
+async function runLighthouse(url, configJson, testRunnerOptions = {}) {
+  if (!buildDevtoolsPromise) buildDevtoolsPromise = buildDevtools();
+  await buildDevtoolsPromise;
+
+  const outputDir = fs.mkdtempSync(os.tmpdir() + '/lh-smoke-cdt-runner-');
+  const args = [
+    'run-devtools',
+    url,
+    `--custom-devtools-frontend=file://${devtoolsDir}/out/Default/gen/front_end`,
+    '--output-dir', outputDir,
+  ];
+  if (configJson) {
+    args.push('--config', JSON.stringify(configJson));
+  }
+
+  const log = await spawnAndLog('yarn', args);
+  const lhr = JSON.parse(fs.readFileSync(`${outputDir}/lhr-0.json`, 'utf-8'));
+  const artifacts = JSON.parse(fs.readFileSync(`${outputDir}/artifacts-0.json`, 'utf-8'));
+
+  if (testRunnerOptions.isDebug) {
+    console.log(`${url} results saved at ${outputDir}`);
+  } else {
+    fs.rmSync(outputDir, {recursive: true, force: true});
+  }
+
+  return {lhr, artifacts, log};
+}
+
+export {
+  runLighthouse,
+};

package/lighthouse-cli/test/smokehouse/readme.md

@@ -118,14 +118,15 @@ Smokehouse Frontends                                        Lighthouse Runners
 |            |    |            |               |   <lhr   |   +--------------+
 +------------+    |            +-------+-------+          |   |              |
                   |                    ^                  +-->+   bundle.js  |
-+------------+    |                    |                      |              |
-|            |    |                    |                      +--------------+
-|   lib.js   +----+                    v
-|            |                +--------+--------+
-+------------+                |                 |
-                              |  report/assert  |
-                              |                 |
-                              +-----------------+
++------------+    |                    |                  |   |              |
+|            |    |                    |                  |   +--------------+
+|   lib.js   +----+                    v                  |
+|            |                +--------+--------+         |
++------------+                |                 |         |   +--------------+
+                              |  report/assert  |         |   |              |
+                              |                 |         +-->+  devtools.js |
+                              +-----------------+             |              |
+                                                              +--------------+
 ```
 
 ### Smokehouse frontends
@@ -142,6 +143,7 @@ Smokehouse Frontends                                        Lighthouse Runners
 
 - `lighthouse-runners/cli.js` - the original test runner, exercising the Lighthouse CLI from command-line argument parsing to the results written to disk on completion.
 - `lighthouse-runners/bundle.js` - a smoke test runner that operates on an already-bundled version of Lighthouse for end-to-end testing of that version.
+- `lighthouse-runners/devtools.js` - a smoke test runner that operates on Lighthouse running from inside DevTools.
 
 ## Custom smoke tests (for plugins et al.)
 

package/lighthouse-core/fraggle-rock/gather/navigation-runner.js

@@ -22,6 +22,7 @@ const {initializeConfig} = require('../config/config.js');
 const {getBaseArtifacts, finalizeArtifacts} = require('./base-artifacts.js');
 const format = require('../../../shared/localization/format.js');
 const LighthouseError = require('../../lib/lh-error.js');
+const URL = require('../../lib/url-shim.js');
 const {getPageLoadError} = require('../../lib/navigation-error.js');
 const Trace = require('../../gather/gatherers/trace.js');
 const DevtoolsLog = require('../../gather/gatherers/devtools-log.js');
@@ -279,7 +280,7 @@ async function _cleanup({requestedUrl, driver, config}) {
  * @return {Promise<LH.RunnerResult|undefined>}
  */
 async function navigation(options) {
-  const {url: requestedUrl, page, configContext = {}} = options;
+  const {url, page, configContext = {}} = options;
   const {config} = initializeConfig(options.config, {...configContext, gatherMode: 'navigation'});
   const computedCache = new Map();
   const internalOptions = {
@@ -289,6 +290,7 @@ async function navigation(options) {
   return Runner.run(
     async () => {
       const driver = new Driver(page);
+      const requestedUrl = URL.normalizeUrl(url);
       const context = {driver, config, requestedUrl, options: internalOptions};
       const {baseArtifacts} = await _setup(context);
       const {artifacts} = await _navigations({...context, baseArtifacts, computedCache});
@@ -297,7 +299,6 @@ async function navigation(options) {
       return finalizeArtifacts(baseArtifacts, artifacts);
     },
     {
-      url: requestedUrl,
       config,
       computedCache: new Map(),
     }

package/lighthouse-core/fraggle-rock/gather/snapshot-runner.js

@@ -51,7 +51,6 @@ async function snapshot(options) {
       return finalizeArtifacts(baseArtifacts, artifacts);
     },
     {
-      url,
       config,
       computedCache,
     }

package/lighthouse-core/fraggle-rock/gather/timespan-runner.js

@@ -64,7 +64,6 @@ async function startTimespan(options) {
           return finalizeArtifacts(baseArtifacts, artifacts);
         },
         {
-          url: finalUrl,
           config,
           computedCache,
         }

package/lighthouse-core/index.js

@@ -9,6 +9,7 @@ const Runner = require('./runner.js');
 const log = require('lighthouse-logger');
 const ChromeProtocol = require('./gather/connections/cri.js');
 const Config = require('./config/config.js');
+const URL = require('./lib/url-shim.js');
 
 /** @typedef {import('./gather/connections/connection.js')} Connection */
 
@@ -42,12 +43,12 @@ async function lighthouse(url, flags = {}, configJSON, userConnection) {
 
   const config = generateConfig(configJSON, flags);
   const computedCache = new Map();
-  const options = {url, config, computedCache};
+  const options = {config, computedCache};
   const connection = userConnection || new ChromeProtocol(flags.port, flags.hostname);
 
   // kick off a lighthouse run
-  /** @param {{requestedUrl: string}} runnerData */
-  const gatherFn = ({requestedUrl}) => {
+  const gatherFn = () => {
+    const requestedUrl = URL.normalizeUrl(url);
     return Runner._gatherArtifactsFromBrowser(requestedUrl, options, connection);
   };
   return Runner.run(gatherFn, options);

package/lighthouse-core/lib/url-shim.js

@@ -10,6 +10,7 @@
  */
 
 const {Util} = require('../util-commonjs.js');
+const LHError = require('../lib/lh-error.js');
 
 /** @typedef {import('./network-request.js')} NetworkRequest */
 
@@ -248,6 +249,20 @@ class URLShim extends URL {
     if (ext === 'jpg') return 'image/jpeg';
     return `image/${ext}`;
   }
+
+  /**
+   * @param {string|undefined} url
+   * @return {string}
+   */
+  static normalizeUrl(url) {
+    // Verify the url is valid and that protocol is allowed
+    if (url && this.isValid(url) && this.isProtocolAllowed(url)) {
+      // Use canonicalized URL (with trailing slashes and such)
+      return new URL(url).href;
+    } else {
+      throw new LHError(LHError.errors.INVALID_URL);
+    }
+  }
 }
 
 URLShim.URL = URL;

package/lighthouse-core/runner.js

@@ -16,7 +16,6 @@ const stackPacks = require('./lib/stack-packs.js');
 const assetSaver = require('./lib/asset-saver.js');
 const fs = require('fs');
 const path = require('path');
-const URL = require('./lib/url-shim.js');
 const Sentry = require('./lib/sentry.js');
 const generateReport = require('../report/generator/report-generator.js').generateReport;
 const LHError = require('./lib/lh-error.js');
@@ -29,8 +28,8 @@ const {version: lighthouseVersion} = require('../package.json');
 class Runner {
   /**
    * @template {LH.Config.Config | LH.Config.FRConfig} TConfig
-   * @param {(runnerData: {requestedUrl: string, config: TConfig, driverMock?: Driver}) => Promise<LH.Artifacts>} gatherFn
-   * @param {{config: TConfig, computedCache: Map<string, ArbitraryEqualityMap>, url?: string, driverMock?: Driver}} runOpts
+   * @param {(runnerData: {config: TConfig, driverMock?: Driver}) => Promise<LH.Artifacts>} gatherFn
+   * @param {{config: TConfig, computedCache: Map<string, ArbitraryEqualityMap>, driverMock?: Driver}} runOpts
    * @return {Promise<LH.RunnerResult|undefined>}
    */
   static async run(gatherFn, runOpts) {
@@ -52,47 +51,7 @@ class Runner {
         data: sentryContext?.extra,
       });
 
-      // User can run -G solo, -A solo, or -GA together
-      // -G and -A will run partial lighthouse pipelines,
-      // and -GA will run everything plus save artifacts and lhr to disk.
-
-      // Gather phase
-      // Either load saved artifacts off disk or from the browser
-      let artifacts;
-      let requestedUrl;
-      if (settings.auditMode && !settings.gatherMode) {
-        // No browser required, just load the artifacts from disk.
-        const path = Runner._getDataSavePath(settings);
-        artifacts = assetSaver.loadArtifacts(path);
-        requestedUrl = artifacts.URL.requestedUrl;
-
-        if (!requestedUrl) {
-          throw new Error('Cannot run audit mode on empty URL');
-        }
-        if (runOpts.url && !URL.equalWithExcludedFragments(runOpts.url, requestedUrl)) {
-          throw new Error('Cannot run audit mode on different URL');
-        }
-      } else {
-        // verify the url is valid and that protocol is allowed
-        if (runOpts.url && URL.isValid(runOpts.url) && URL.isProtocolAllowed(runOpts.url)) {
-          // Use canonicalized URL (with trailing slashes and such)
-          requestedUrl = new URL(runOpts.url).href;
-        } else {
-          throw new LHError(LHError.errors.INVALID_URL);
-        }
-
-        artifacts = await gatherFn({
-          requestedUrl,
-          config: runOpts.config,
-          driverMock: runOpts.driverMock,
-        });
-
-        // -G means save these to ./latest-run, etc.
-        if (settings.gatherMode) {
-          const path = Runner._getDataSavePath(settings);
-          await assetSaver.saveArtifacts(artifacts, path);
-        }
-      }
+      const artifacts = await this.gatherAndManageArtifacts(gatherFn, runOpts);
 
       // Potentially quit early
       if (settings.gatherMode && !settings.auditMode) return;
@@ -133,7 +92,7 @@ class Runner {
       /** @type {LH.RawIcu<LH.Result>} */
       const i18nLhr = {
         lighthouseVersion,
-        requestedUrl,
+        requestedUrl: artifacts.URL.requestedUrl,
         finalUrl: artifacts.URL.finalUrl,
         fetchTime: artifacts.fetchTime,
         gatherMode: artifacts.GatherContext.gatherMode,
@@ -184,6 +143,47 @@ class Runner {
     }
   }
 
+  /**
+   * User can run -G solo, -A solo, or -GA together
+   * -G and -A will run partial lighthouse pipelines,
+   * and -GA will run everything plus save artifacts and lhr to disk.
+   *
+   * @template {LH.Config.Config | LH.Config.FRConfig} TConfig
+   * @param {(runnerData: {config: TConfig, driverMock?: Driver}) => Promise<LH.Artifacts>} gatherFn
+   * @param {{config: TConfig, driverMock?: Driver}} options
+   * @return {Promise<LH.Artifacts>}
+   */
+  static async gatherAndManageArtifacts(gatherFn, options) {
+    const settings = options.config.settings;
+
+    // Gather phase
+    // Either load saved artifacts from disk or from the browser.
+    let artifacts;
+    if (settings.auditMode && !settings.gatherMode) {
+      // No browser required, just load the artifacts from disk.
+      const path = this._getDataSavePath(settings);
+      artifacts = assetSaver.loadArtifacts(path);
+      const requestedUrl = artifacts.URL.requestedUrl;
+
+      if (!requestedUrl) {
+        throw new Error('Cannot run audit mode on empty URL');
+      }
+    } else {
+      artifacts = await gatherFn({
+        config: options.config,
+        driverMock: options.driverMock,
+      });
+
+      // -G means save these to disk (e.g. ./latest-run).
+      if (settings.gatherMode) {
+        const path = this._getDataSavePath(settings);
+        await assetSaver.saveArtifacts(artifacts, path);
+      }
+    }
+
+    return artifacts;
+  }
+
   /**
    * This handles both the auditMode case where gatherer entries need to be merged in and
    * the gather/audit case where timingEntriesFromRunner contains all entries from this run,

package/lighthouse-core/scripts/download-chrome.sh

@@ -10,10 +10,23 @@
 
 set -euo pipefail
 
-if [ "$OSTYPE" == "msys" ]; then
+unameOut="$(uname -s)"
+case "${unameOut}" in
+  Linux*)     machine=Linux;;
+  Darwin*)    machine=Mac;;
+  MINGW*)     machine=MinGw;;
+  *)          machine="UNKNOWN:${unameOut}"
+esac
+
+if [ "$machine" == "MinGw" ]; then
   url="https://download-chromium.appspot.com/dl/Win?type=snapshots"
-else
+elif [ "$machine" == "Linux" ]; then
   url="https://download-chromium.appspot.com/dl/Linux_x64?type=snapshots"
+elif [ "$machine" == "Mac" ]; then
+  url="https://download-chromium.appspot.com/dl/Mac?type=snapshots"
+else
+  echo "unsupported platform"
+  exit 1
 fi
 
 if [ -e "$CHROME_PATH" ]; then

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lighthouse",
-  "version": "9.2.0-dev.20220104",
+  "version": "9.2.0-dev.20220108",
   "description": "Automated auditing, performance metrics, and best practices for the web.",
   "main": "./lighthouse-core/index.js",
   "bin": {
@@ -170,7 +170,7 @@
     "resolve": "^1.20.0",
     "rollup": "^2.52.7",
     "rollup-plugin-node-resolve": "^5.2.0",
-    "rollup-plugin-polyfill-node": "^0.7.0",
+    "rollup-plugin-polyfill-node": "^0.8.0",
     "rollup-plugin-replace": "^2.2.0",
     "rollup-plugin-shim": "^1.0.0",
     "rollup-plugin-terser": "^7.0.2",