lighthouse 9.5.0-dev.20220621 → 9.5.0-dev.20220622

package/lighthouse-cli/bin.js

@@ -31,6 +31,7 @@ import {runLighthouse} from './run.js';
 import lighthouse from '../lighthouse-core/index.js';
 import {askPermission} from './sentry-prompt.js';
 import {LH_ROOT} from '../root.js';
+import {getConfigDisplayString} from '../lighthouse-core/fraggle-rock/config/config.js';
 
 const pkg = JSON.parse(fs.readFileSync(LH_ROOT + '/package.json', 'utf-8'));
 
@@ -120,8 +121,13 @@ async function begin() {
   }
 
   if (cliFlags.printConfig) {
-    const config = await lighthouse.generateConfig(configJson, cliFlags);
-    process.stdout.write(config.getPrintString());
+    if (cliFlags.legacyNavigation) {
+      const config = await lighthouse.generateLegacyConfig(configJson, cliFlags);
+      process.stdout.write(config.getPrintString());
+    } else {
+      const config = await lighthouse.generateConfig(configJson, cliFlags);
+      process.stdout.write(getConfigDisplayString(config));
+    }
     return;
   }
 

package/lighthouse-cli/test/smokehouse/__snapshots__/report-assert-test.js.snap

@@ -1,5 +1,37 @@
 // Jest Snapshot v1, https://goo.gl/fbAQLP
 
+exports[`getAssertionReport works (multiple failing) 1`] = `
+"X difference at cumulative-layout-shift audit.details.items.length
+              expected: []
+                 found: [{\\"cumulativeLayoutShiftMainFrame\\":0.13570762803819444,\\"totalCumulativeLayoutShift\\":0.13570762803819444}]
+
+
+  X difference at cumulative-layout-shift audit.details.blah
+              expected: 123
+                 found: undefined
+
+          found result:
+      {
+        \\"id\\": \\"cumulative-layout-shift\\",
+        \\"title\\": \\"Cumulative Layout Shift\\",
+        \\"description\\": \\"Cumulative Layout Shift measures the movement of visible elements within the viewport. [Learn more](https://web.dev/cls/).\\",
+        \\"score\\": 0.8,
+        \\"scoreDisplayMode\\": \\"numeric\\",
+        \\"numericValue\\": 0.13570762803819444,
+        \\"numericUnit\\": \\"unitless\\",
+        \\"displayValue\\": \\"0.136\\",
+        \\"details\\": {
+          \\"type\\": \\"debugdata\\",
+          \\"items\\": [
+            {
+              \\"cumulativeLayoutShiftMainFrame\\": 0.13570762803819444,
+              \\"totalCumulativeLayoutShift\\": 0.13570762803819444
+            }
+          ]
+        }
+      }"
+`;
+
 exports[`getAssertionReport works (trivial failing) 1`] = `
 "X difference at cumulative-layout-shift audit.details.items.length
               expected: []
@@ -26,3 +58,14 @@ exports[`getAssertionReport works (trivial failing) 1`] = `
         }
       }"
 `;
+
+exports[`getAssertionReport works (trivial failing, actual undefined) 1`] = `
+"Error: Config did not trigger run of expected audit cumulative-layout-shift-no-exist
+
+  X difference at cumulative-layout-shift-no-exist audit
+              expected: {\\"details\\":{\\"items\\":[]}}
+                 found: undefined
+
+          found result:
+      undefined"
+`;

package/lighthouse-cli/test/smokehouse/report-assert-test.js

@@ -6,146 +6,175 @@
 
 /* eslint-disable no-control-regex */
 
-import {findDifference, getAssertionReport} from './report-assert.js';
+import {findDifferences, getAssertionReport} from './report-assert.js';
 import {readJson} from '../../../root.js';
 
-describe('findDifference', () => {
+describe('findDiffersences', () => {
   const testCases = {
     'works (trivial passing)': {
       actual: {},
       expected: {},
-      diff: null,
+      diffs: null,
     },
     'works (trivial fail)': {
       actual: {},
       expected: {a: 1},
-      diff: {path: '.a', actual: undefined, expected: 1},
+      diffs: [{path: '.a', actual: undefined, expected: 1}],
+    },
+    'works (trivial fail, actual undefined)': {
+      actual: undefined,
+      expected: {a: 1},
+      diffs: [{path: '', actual: undefined, expected: {a: 1}}],
     },
     'works (trivial fail, nested)': {
       actual: {a: {b: 2}},
       expected: {a: {b: 1}},
-      diff: {path: '.a.b', actual: 2, expected: 1},
+      diffs: [{path: '.a.b', actual: 2, expected: 1}],
+    },
+    'works (trivial fail, nested actual undefined)': {
+      actual: {a: undefined},
+      expected: {a: {b: 1}},
+      diffs: [{path: '.a', actual: undefined, expected: {b: 1}}],
+    },
+    'works (multiple fail 1)': {
+      actual: {},
+      expected: {a: 1, b: 2},
+      diffs: [
+        {path: '.a', actual: undefined, expected: 1},
+        {path: '.b', actual: undefined, expected: 2},
+      ],
+    },
+    'works (multiple fail 2)': {
+      actual: {nested: {array: [0, 1, 2]}},
+      expected: {nested: {array: [2, 1, 0]}},
+      diffs: [
+        {path: '.nested.array[0]', actual: 0, expected: 2},
+        {path: '.nested.array[2]', actual: 2, expected: 0},
+      ],
     },
 
     'range (1)': {
       actual: {duration: 100},
       expected: {duration: '>=100'},
-      diff: null,
+      diffs: null,
     },
     'range (2)': {
       actual: {},
       expected: {duration: '>=100'},
-      diff: {path: '.duration', actual: undefined, expected: '>=100'},
+      diffs: [{path: '.duration', actual: undefined, expected: '>=100'}],
     },
     'range (3)': {
       actual: {duration: 100},
       expected: {duration: '>100'},
-      diff: {path: '.duration', actual: 100, expected: '>100'},
+      diffs: [{path: '.duration', actual: 100, expected: '>100'}],
     },
     'range (4)': {
       actual: {duration: 100},
       expected: {duration: '<100'},
-      diff: {path: '.duration', actual: 100, expected: '<100'},
+      diffs: [{path: '.duration', actual: 100, expected: '<100'}],
     },
 
     'array (1)': {
       actual: {prices: [0, 1, 2, 3, 4, 5]},
       expected: {prices: {length: 6}},
-      diff: null,
+      diffs: null,
     },
     'array (2)': {
       actual: {prices: [0, 1, 2, 3, 4, 5]},
       expected: {prices: {length: '>0'}},
-      diff: null,
+      diffs: null,
     },
     'array (3)': {
       actual: {prices: [0, 1, 2, 3, 4, 5]},
       expected: {prices: [0, 1, 2, 3, 4, 5]},
-      diff: null,
+      diffs: null,
     },
     'array (4)': {
       actual: {prices: [0, 1, 2, 3, 4, 5]},
       expected: {prices: [0, 1, 2, 3, 4, 5, 6]},
-      diff: {path: '.prices[6]', actual: undefined, expected: 6},
+      diffs: [
+        {path: '.prices[6]', actual: undefined, expected: 6},
+        {path: '.prices.length', actual: [0, 1, 2, 3, 4, 5], expected: [0, 1, 2, 3, 4, 5, 6]},
+      ],
     },
     'array (5)': {
       actual: {prices: [0, 1, 2, 3, 4, 5]},
       expected: {prices: []},
-      diff: {path: '.prices.length', actual: [0, 1, 2, 3, 4, 5], expected: []},
+      diffs: [{path: '.prices.length', actual: [0, 1, 2, 3, 4, 5], expected: []}],
     },
     'array (6)': {
       actual: {prices: [0, 1, 2, 3, 4, 5]},
       expected: {prices: {'3': '>=3'}},
-      diff: null,
+      diffs: null,
     },
     'array (7)': {
       actual: {prices: [0, 1, 2, {nested: 3}, 4, 5]},
       expected: {prices: {'3': {nested: '>3'}}},
-      diff: {path: '.prices[3].nested', actual: 3, expected: '>3'},
+      diffs: [{path: '.prices[3].nested', actual: 3, expected: '>3'}],
     },
 
     '_includes (1)': {
       actual: {prices: [0, 1, 2, 3, 4, 5]},
       expected: {prices: {_includes: [4]}},
-      diff: null,
+      diffs: null,
     },
     '_includes (2)': {
       actual: {prices: [0, 1, 2, 3, 4, 5]},
       expected: {prices: {_includes: [4, 4]}},
-      diff: {path: '.prices', actual: 'Item not found in array', expected: 4},
+      diffs: [{path: '.prices', actual: 'Item not found in array', expected: 4}],
     },
     '_includes (3)': {
       actual: {prices: [0, 1, 2, 3, 4, 5]},
       expected: {prices: {_includes: [100]}},
-      diff: {path: '.prices', actual: 'Item not found in array', expected: 100},
+      diffs: [{path: '.prices', actual: 'Item not found in array', expected: 100}],
     },
     '_includes (4)': {
       actual: {prices: ['0', '1', '2', '3', '4', '5']},
       expected: {prices: {_includes: [/\d/, /\d/, /\d/, /\d/, /\d/, /\d/]}},
-      diff: null,
+      diffs: null,
     },
 
     '_excludes (1)': {
       actual: {prices: [0, 1, 2, 3, 4, 5]},
       expected: {prices: {_excludes: [100]}},
-      diff: null,
+      diffs: null,
     },
     '_excludes (2)': {
       actual: {prices: [0, 1, 2, 3, 4, 5]},
       expected: {prices: {_excludes: [2]}},
-      diff: {path: '.prices', actual: 2, expected: {
+      diffs: [{path: '.prices', actual: 2, expected: {
         expectedExclusion: 2,
         message: 'Expected to not find matching entry via _excludes',
-      }},
+      }}],
     },
 
     '_includes and _excludes (1)': {
       actual: {prices: [0, 1, 2, 3, 4, 5]},
       expected: {prices: {_includes: [2], _excludes: [2]}},
-      diff: null,
+      diffs: null,
     },
     // Order matters.
     '_includes and _excludes (2)': {
       actual: {prices: [0, 1, 2, 3, 4, 5]},
       expected: {prices: {_excludes: [2], _includes: [2]}},
-      diff: {path: '.prices', actual: 2, expected: {
+      diffs: [{path: '.prices', actual: 2, expected: {
         expectedExclusion: 2,
         message: 'Expected to not find matching entry via _excludes',
-      }},
+      }}],
     },
     '_includes and _excludes (3)': {
       actual: {prices: [0, 1, 2, 3, 4, 5]},
       expected: {prices: {_includes: [2], _excludes: [2, 1]}},
-      diff: {path: '.prices', actual: 1, expected: {
+      diffs: [{path: '.prices', actual: 1, expected: {
         expectedExclusion: 1,
         message: 'Expected to not find matching entry via _excludes',
-      }},
+      }}],
     },
   };
 
-  for (const [testName, {actual, expected, diff}] of Object.entries(testCases)) {
+  for (const [testName, {actual, expected, diffs}] of Object.entries(testCases)) {
     it(testName, () => {
-      expect(findDifference('', actual, expected)).toEqual(diff);
+      expect(findDifferences('', actual, expected)).toEqual(diffs);
     });
   }
 });
@@ -195,4 +224,41 @@ describe('getAssertionReport', () => {
     expect(report).toMatchObject({passed: 3, failed: 1});
     expect(clean(report.log)).toMatchSnapshot();
   });
+
+  it('works (trivial failing, actual undefined)', () => {
+    const report = getAssertionReport({lhr, artifacts}, {
+      lhr: {
+        audits: {
+          'cumulative-layout-shift-no-exist': {
+            details: {
+              items: [],
+            },
+          },
+        },
+        requestedUrl: 'http://localhost:10200/dobetterweb/dbw_tester.html',
+        finalUrl: 'http://localhost:10200/dobetterweb/dbw_tester.html',
+      },
+    });
+    expect(report).toMatchObject({passed: 3, failed: 1});
+    expect(clean(report.log)).toMatchSnapshot();
+  });
+
+  it('works (multiple failing)', () => {
+    const report = getAssertionReport({lhr, artifacts}, {
+      lhr: {
+        audits: {
+          'cumulative-layout-shift': {
+            details: {
+              items: [],
+              blah: 123,
+            },
+          },
+        },
+        requestedUrl: 'http://localhost:10200/dobetterweb/dbw_tester.html',
+        finalUrl: 'http://localhost:10200/dobetterweb/dbw_tester.html',
+      },
+    });
+    expect(report).toMatchObject({passed: 3, failed: 1});
+    expect(clean(report.log)).toMatchSnapshot();
+  });
 });

package/lighthouse-cli/test/smokehouse/report-assert.js

@@ -28,7 +28,7 @@ import {chromiumVersionCheck} from './version-check.js';
  * @property {any} actual
  * @property {any} expected
  * @property {boolean} equal
- * @property {Difference|null} [diff]
+ * @property {Difference[]|null} diffs
  */
 
 const NUMBER_REGEXP = /(?:\d|\.)+/.source;
@@ -86,9 +86,9 @@ function matchesExpectation(actual, expected) {
  * @param {string} path
  * @param {*} actual
  * @param {*} expected
- * @return {(Difference|null)}
+ * @return {Difference[]|null}
  */
-function findDifference(path, actual, expected) {
+function findDifferences(path, actual, expected) {
   if (matchesExpectation(actual, expected)) {
     return null;
   }
@@ -96,13 +96,15 @@ function findDifference(path, actual, expected) {
   // If they aren't both an object we can't recurse further, so this is the difference.
   if (actual === null || expected === null || typeof actual !== 'object' ||
       typeof expected !== 'object' || expected instanceof RegExp) {
-    return {
+    return [{
       path,
       actual,
       expected,
-    };
+    }];
   }
 
+  /** @type {Difference[]} */
+  const diffs = [];
   let inclExclCopy;
 
   // We only care that all expected's own properties are on actual (and not the other way around).
@@ -118,27 +120,27 @@ function findDifference(path, actual, expected) {
 
       if (!Array.isArray(expectedValue)) throw new Error('Array subset must be array');
       if (!Array.isArray(actual)) {
-        return {
+        diffs.push({
           path,
           actual: 'Actual value is not an array',
           expected,
-        };
+        });
       }
 
       for (const expectedEntry of expectedValue) {
         const matchingIndex =
           inclExclCopy.findIndex(actualEntry =>
-            !findDifference(keyPath, actualEntry, expectedEntry));
+            !findDifferences(keyPath, actualEntry, expectedEntry));
         if (matchingIndex !== -1) {
           inclExclCopy.splice(matchingIndex, 1);
           continue;
         }
 
-        return {
+        diffs.push({
           path,
           actual: 'Item not found in array',
           expected: expectedEntry,
-        };
+        });
       }
 
       continue;
@@ -155,16 +157,16 @@ function findDifference(path, actual, expected) {
       const expectedExclusions = expectedValue;
       for (const expectedExclusion of expectedExclusions) {
         const matchingIndex = arrToCheckAgainst.findIndex(actualEntry =>
-            !findDifference(keyPath, actualEntry, expectedExclusion));
+            !findDifferences(keyPath, actualEntry, expectedExclusion));
         if (matchingIndex !== -1) {
-          return {
+          diffs.push({
             path,
             actual: arrToCheckAgainst[matchingIndex],
             expected: {
               message: 'Expected to not find matching entry via _excludes',
               expectedExclusion,
             },
-          };
+          });
         }
       }
 
@@ -172,12 +174,8 @@ function findDifference(path, actual, expected) {
     }
 
     const actualValue = actual[key];
-    const subDifference = findDifference(keyPath, actualValue, expectedValue);
-
-    // Break on first difference found.
-    if (subDifference) {
-      return subDifference;
-    }
+    const subDifferences = findDifferences(keyPath, actualValue, expectedValue);
+    if (subDifferences) diffs.push(...subDifferences);
   }
 
   // If the expected value is an array, assert the length as well.
@@ -185,14 +183,15 @@ function findDifference(path, actual, expected) {
   // but requires using an object literal (ex: {0: x, 1: y, 2: z} matches [x, y, z, q, w, e] and
   // {0: x, 1: y, 2: z, length: 5} does not match [x, y, z].
   if (Array.isArray(expected) && actual.length !== expected.length) {
-    return {
+    diffs.push({
       path: `${path}.length`,
       actual,
       expected,
-    };
+    });
   }
 
-  return null;
+  if (diffs.length === 0) return null;
+  return diffs;
 }
 
 /**
@@ -202,14 +201,14 @@ function findDifference(path, actual, expected) {
  * @return {Comparison}
  */
 function makeComparison(name, actualResult, expectedResult) {
-  const diff = findDifference(name, actualResult, expectedResult);
+  const diffs = findDifferences(name, actualResult, expectedResult);
 
   return {
     name,
     actual: actualResult,
     expected: expectedResult,
-    equal: !diff,
-    diff,
+    equal: !diffs,
+    diffs,
   };
 }
 
@@ -427,19 +426,21 @@ function reportAssertion(localConsole, assertion) {
           log.greenify(assertion.actual));
     }
   } else {
-    if (assertion.diff) {
-      const diff = assertion.diff;
-      const fullActual = String(JSON.stringify(assertion.actual, null, 2))
-          .replace(/\n/g, '\n      ');
-      const msg = `
+    if (assertion.diffs?.length) {
+      for (const diff of assertion.diffs) {
+        const msg = `
   ${log.redify(log.cross)} difference at ${log.bold}${diff.path}${log.reset}
               expected: ${JSON.stringify(diff.expected)}
-                 found: ${JSON.stringify(diff.actual)}
+                 found: ${JSON.stringify(diff.actual)}\n`;
+        localConsole.log(msg);
+      }
 
-          found result:
+      const fullActual = assertion.actual !== undefined ?
+        JSON.stringify(assertion.actual, null, 2).replace(/\n/g, '\n      ') :
+        'undefined\n      ';
+      localConsole.log(`          found result:
       ${log.redify(fullActual)}
-`;
-      localConsole.log(msg);
+  `);
     } else {
       localConsole.log(`  ${log.redify(log.cross)} ${assertion.name}:
               expected: ${JSON.stringify(assertion.expected)}
@@ -491,5 +492,5 @@ function getAssertionReport(actual, expected, reportOptions = {}) {
 
 export {
   getAssertionReport,
-  findDifference,
+  findDifferences,
 };

package/lighthouse-core/audits/byte-efficiency/unused-javascript.js

@@ -133,7 +133,7 @@ class UnusedJavaScript extends ByteEfficiencyAudit {
           })
           .filter(d => d.unused >= bundleSourceUnusedThreshold);
 
-        const commonSourcePrefix = commonPrefix([...bundle.map.sourceInfos.keys()]);
+        const commonSourcePrefix = commonPrefix(bundle.map.sourceURLs());
         item.subItems = {
           type: 'subitems',
           items: topUnusedSourceSizes.map(({source, unused, total}) => {

package/lighthouse-core/config/config-helpers.js

@@ -578,6 +578,20 @@ function deepCloneConfigJson(json) {
   return cloned;
 }
 
+/**
+ * @param {LH.Flags} flags
+ * @return {LH.Config.FRContext}
+ */
+function flagsToFRContext(flags) {
+  return {
+    configPath: flags?.configPath,
+    settingsOverrides: flags,
+    logLevel: flags?.logLevel,
+    hostname: flags?.hostname,
+    port: flags?.port,
+  };
+}
+
 module.exports = {
   deepClone,
   deepCloneConfigJson,
@@ -589,4 +603,5 @@ module.exports = {
   resolveGathererToDefn,
   resolveModulePath,
   resolveSettings,
+  flagsToFRContext,
 };

package/lighthouse-core/fraggle-rock/config/config.js

@@ -8,6 +8,7 @@
 const path = require('path');
 const log = require('lighthouse-logger');
 const Runner = require('../../runner.js');
+const format = require('../../../shared/localization/format.js');
 const defaultConfig = require('./default-config.js');
 const {defaultNavigationConfig, nonSimulatedPassConfigOverrides} = require('../../config/constants.js'); // eslint-disable-line max-len
 const {
@@ -279,4 +280,47 @@ async function initializeConfig(configJSON, context) {
   return {config, warnings};
 }
 
-module.exports = {resolveWorkingCopy, initializeConfig};
+/**
+ * @param {LH.Config.FRConfig} config
+ * @return {string}
+ */
+function getConfigDisplayString(config) {
+  /** @type {LH.Config.FRConfig} */
+  const jsonConfig = JSON.parse(JSON.stringify(config));
+
+  if (jsonConfig.navigations) {
+    for (const navigation of jsonConfig.navigations) {
+      for (let i = 0; i < navigation.artifacts.length; ++i) {
+        // @ts-expect-error Breaking the Config.AnyArtifactDefn type.
+        navigation.artifacts[i] = navigation.artifacts[i].id;
+      }
+    }
+  }
+
+  if (jsonConfig.artifacts) {
+    for (const artifactDefn of jsonConfig.artifacts) {
+      // @ts-expect-error Breaking the Config.AnyArtifactDefn type.
+      artifactDefn.gatherer = artifactDefn.gatherer.path;
+      // Dependencies are not declared on Config JSON
+      artifactDefn.dependencies = undefined;
+    }
+  }
+
+  if (jsonConfig.audits) {
+    for (const auditDefn of jsonConfig.audits) {
+      // @ts-expect-error Breaking the Config.AuditDefn type.
+      auditDefn.implementation = undefined;
+      if (Object.keys(auditDefn.options).length === 0) {
+        // @ts-expect-error Breaking the Config.AuditDefn type.
+        auditDefn.options = undefined;
+      }
+    }
+  }
+
+  // Printed config is more useful with localized strings.
+  format.replaceIcuMessages(jsonConfig, jsonConfig.settings.locale);
+
+  return JSON.stringify(jsonConfig, null, 2);
+}
+
+module.exports = {resolveWorkingCopy, initializeConfig, getConfigDisplayString};

package/lighthouse-core/fraggle-rock/gather/driver.js

@@ -6,9 +6,9 @@
 'use strict';
 
 const log = require('lighthouse-logger');
-const ProtocolSession = require('./session.js');
 const ExecutionContext = require('../../gather/driver/execution-context.js');
 const Fetcher = require('../../gather/fetcher.js');
+const TargetManager = require('../../gather/driver/target-manager.js');
 
 /** @return {*} */
 const throwNotConnectedFn = () => {
@@ -24,8 +24,6 @@ const throwingSession = {
   on: throwNotConnectedFn,
   once: throwNotConnectedFn,
   off: throwNotConnectedFn,
-  addProtocolMessageListener: throwNotConnectedFn,
-  removeProtocolMessageListener: throwNotConnectedFn,
   sendCommand: throwNotConnectedFn,
   dispose: throwNotConnectedFn,
 };
@@ -37,6 +35,8 @@ class Driver {
    */
   constructor(page) {
     this._page = page;
+    /** @type {TargetManager|undefined} */
+    this._targetManager = undefined;
     /** @type {ExecutionContext|undefined} */
     this._executionContext = undefined;
     /** @type {Fetcher|undefined} */
@@ -57,6 +57,11 @@ class Driver {
     return this._fetcher;
   }
 
+  get targetManager() {
+    if (!this._targetManager) return throwNotConnectedFn();
+    return this._targetManager;
+  }
+
   /** @return {Promise<string>} */
   async url() {
     return this._page.url();
@@ -67,8 +72,10 @@ class Driver {
     if (this.defaultSession !== throwingSession) return;
     const status = {msg: 'Connecting to browser', id: 'lh:driver:connect'};
     log.time(status);
-    const session = await this._page.target().createCDPSession();
-    this.defaultSession = new ProtocolSession(session);
+    const cdpSession = await this._page.target().createCDPSession();
+    this._targetManager = new TargetManager(cdpSession);
+    await this._targetManager.enable();
+    this.defaultSession = this._targetManager.rootSession();
     this._executionContext = new ExecutionContext(this.defaultSession);
     this._fetcher = new Fetcher(this.defaultSession);
     log.timeEnd(status);
@@ -77,6 +84,7 @@ class Driver {
   /** @return {Promise<void>} */
   async disconnect() {
     if (this.defaultSession === throwingSession) return;
+    this._targetManager?.disable();
     await this.defaultSession.dispose();
   }
 }