lighthouse 9.4.0 → 9.5.0

package/lighthouse-cli/run.js

@@ -207,7 +207,11 @@ async function runLighthouseWithFraggleRock(url, flags, config, launchedChrome)
   const browser = await puppeteer.connect({browserURL: `http://localhost:${launchedChrome.port}`});
   const page = await browser.newPage();
   flags.channel = 'fraggle-rock-cli';
-  const configContext = {configPath: flags.configPath, settingsOverrides: flags};
+  const configContext = {
+    configPath: flags.configPath,
+    settingsOverrides: flags,
+    logLevel: flags.logLevel,
+  };
   return fraggleRock.navigation(url, {page, config, configContext});
 }
 

package/lighthouse-cli/test/smokehouse/core-tests.js

@@ -33,6 +33,7 @@ import offlineReady from './test-definitions/offline-ready.js';
 import offlineSwBroken from './test-definitions/offline-sw-broken.js';
 import offlineSwSlow from './test-definitions/offline-sw-slow.js';
 import oopifRequests from './test-definitions/oopif-requests.js';
+import oopifScripts from './test-definitions/oopif-scripts.js';
 import perfBudgets from './test-definitions/perf-budgets.js';
 import perfDebug from './test-definitions/perf-debug.js';
 import perfDiagnosticsAnimations from './test-definitions/perf-diagnostics-animations.js';
@@ -53,6 +54,7 @@ import redirectsHistoryPushState from './test-definitions/redirects-history-push
 import redirectsMultipleServer from './test-definitions/redirects-multiple-server.js';
 import redirectsSingleClient from './test-definitions/redirects-single-client.js';
 import redirectsSingleServer from './test-definitions/redirects-single-server.js';
+import redirectsSelf from './test-definitions/redirects-self.js';
 import screenshot from './test-definitions/screenshot.js';
 import seoFailing from './test-definitions/seo-failing.js';
 import seoPassing from './test-definitions/seo-passing.js';
@@ -91,6 +93,7 @@ const smokeTests = [
   offlineSwBroken,
   offlineSwSlow,
   oopifRequests,
+  oopifScripts,
   perfBudgets,
   perfDebug,
   perfDiagnosticsAnimations,
@@ -111,6 +114,7 @@ const smokeTests = [
   redirectsMultipleServer,
   redirectsSingleClient,
   redirectsSingleServer,
+  redirectsSelf,
   screenshot,
   seoFailing,
   seoPassing,

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

@@ -13,11 +13,13 @@
 
 /* eslint-disable no-console */
 
-import cloneDeep from 'lodash.clonedeep';
+import _ from 'lodash';
 
 import smokeTests from '../core-tests.js';
 import {runSmokehouse, getShardedDefinitions} from '../smokehouse.js';
 
+const {cloneDeep} = _;
+
 /**
  * @param {Smokehouse.SmokehouseLibOptions} options
  */

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

@@ -17,7 +17,7 @@ import path from 'path';
 import fs from 'fs';
 import url from 'url';
 
-import cloneDeep from 'lodash.clonedeep';
+import _ from 'lodash';
 import yargs from 'yargs';
 import * as yargsHelpers from 'yargs/helpers';
 import log from 'lighthouse-logger';
@@ -26,6 +26,8 @@ import {runSmokehouse, getShardedDefinitions} from '../smokehouse.js';
 import {updateTestDefnFormat} from './back-compat-util.js';
 import {LH_ROOT} from '../../../../root.js';
 
+const {cloneDeep} = _;
+
 const coreTestDefnsPath =
   path.join(LH_ROOT, 'lighthouse-cli/test/smokehouse/core-tests.js');
 
@@ -186,6 +188,7 @@ async function begin() {
     console.log('\n✨ Be sure to have recently run this: yarn build-all');
   }
   const {runLighthouse} = await import(runnerPath);
+  runLighthouse.runnerName = argv.runner;
 
   // Find test definition file and filter by requestedTestIds.
   let testDefnPath = argv.testsPath || coreTestDefnsPath;

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

@@ -75,10 +75,13 @@ async function runLighthouse(url, configJson, testRunnerOptions = {}) {
   await buildDevtoolsPromise;
 
   const outputDir = fs.mkdtempSync(os.tmpdir() + '/lh-smoke-cdt-runner-');
+  const chromeFlags = [
+    `--custom-devtools-frontend=file://${devtoolsDir}/out/Default/gen/front_end`,
+  ];
   const args = [
     'run-devtools',
     url,
-    `--custom-devtools-frontend=file://${devtoolsDir}/out/Default/gen/front_end`,
+    `--chrome-flags=${chromeFlags.join(' ')}`,
     '--output-dir', outputDir,
   ];
   if (configJson) {

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

@@ -66,6 +66,8 @@ However, if an array literal is used as the expectation, an extra condition is e
 
 Arrays can be checked against a subset of elements using the special `_includes` property. The value of `_includes` _must_ be an array. Each assertion in `_includes` will remove the matching item from consideration for the rest.
 
+Arrays can be asserted to not match any elements using the special `_excludes` property. The value of `_excludes` _must_ be an array. If an `_includes` check is defined before an `_excludes` check, only the element not matched under the previous will be considered.
+
 **Examples**:
 | Actual | Expected | Result |
 | -- | -- | -- |
@@ -73,6 +75,9 @@ Arrays can be checked against a subset of elements using the special `_includes`
 | `[{timeInMs: 5}, {timeInMs: 15}]` | `{length: 2}` | ✅ PASS |
 | `[{timeInMs: 5}, {timeInMs: 15}]` | `{_includes: [{timeInMs: 5}]}` | ✅ PASS |
 | `[{timeInMs: 5}, {timeInMs: 15}]` | `{_includes: [{timeInMs: 5}, {timeInMs: 5}]}` | ❌ FAIL |
+| `[{timeInMs: 5}, {timeInMs: 15}]` | `{_includes: [{timeInMs: 5}], _excludes: [{timeInMs: 5}]}` | ✅ PASS |
+| `[{timeInMs: 5}, {timeInMs: 15}]` | `{_includes: [{timeInMs: 5}], _excludes: [{timeInMs: 15}]}` | ❌ FAIL |
+| `[{timeInMs: 5}, {timeInMs: 15}]` | `{_includes: [{timeInMs: 5}], _excludes: [{}]}` | ❌ FAIL |
 | `[{timeInMs: 5}, {timeInMs: 15}]` | `[{timeInMs: 5}]` | ❌ FAIL |
 
 ### Special environment checks
@@ -104,6 +109,15 @@ If an expectation requires a minimum version of Chromium, use `_minChromiumMiles
   },
 ```
 
+All pruning checks:
+
+- `_minChromiumMilestone`
+- `_maxChromiumMilestone`
+- `_legacyOnly`
+- `_fraggleRockOnly`
+- `_skipInBundled`
+- `_runner` (set to same value provided to CLI --runner flag, ex: `'devtools'`)
+
 ## Pipeline
 
 The different frontends launch smokehouse with a set of tests to run. Smokehouse then coordinates the tests using a particular method of running Lighthouse (CLI, as a bundle, etc).

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

@@ -10,11 +10,13 @@
  * against the results actually collected from Lighthouse.
  */
 
-import cloneDeep from 'lodash.clonedeep';
+import _ from 'lodash';
 import log from 'lighthouse-logger';
 
 import {LocalConsole} from './lib/local-console.js';
 
+const {cloneDeep} = _;
+
 /**
  * @typedef Difference
  * @property {string} path
@@ -103,6 +105,8 @@ function findDifference(path, actual, expected) {
     };
   }
 
+  let inclExclCopy;
+
   // We only care that all expected's own properties are on actual (and not the other way around).
   // Note an expected `undefined` can match an actual that is either `undefined` or not defined.
   for (const key of Object.keys(expected)) {
@@ -112,6 +116,8 @@ function findDifference(path, actual, expected) {
     const expectedValue = expected[key];
 
     if (key === '_includes') {
+      inclExclCopy = [...actual];
+
       if (!Array.isArray(expectedValue)) throw new Error('Array subset must be array');
       if (!Array.isArray(actual)) {
         return {
@@ -121,12 +127,12 @@ function findDifference(path, actual, expected) {
         };
       }
 
-      const actualCopy = [...actual];
       for (const expectedEntry of expectedValue) {
         const matchingIndex =
-          actualCopy.findIndex(actualEntry => !findDifference(keyPath, actualEntry, expectedEntry));
+          inclExclCopy.findIndex(actualEntry =>
+            !findDifference(keyPath, actualEntry, expectedEntry));
         if (matchingIndex !== -1) {
-          actualCopy.splice(matchingIndex, 1);
+          inclExclCopy.splice(matchingIndex, 1);
           continue;
         }
 
@@ -140,6 +146,33 @@ function findDifference(path, actual, expected) {
       continue;
     }
 
+    if (key === '_excludes') {
+      // Re-use state from `_includes` check, if there was one.
+      /** @type {any[]} */
+      const arrToCheckAgainst = inclExclCopy || actual;
+
+      if (!Array.isArray(expectedValue)) throw new Error('Array subset must be array');
+      if (!Array.isArray(actual)) continue;
+
+      const expectedExclusions = expectedValue;
+      for (const expectedExclusion of expectedExclusions) {
+        const matchingIndex = arrToCheckAgainst.findIndex(actualEntry =>
+            !findDifference(keyPath, actualEntry, expectedExclusion));
+        if (matchingIndex !== -1) {
+          return {
+            path,
+            actual: arrToCheckAgainst[matchingIndex],
+            expected: {
+              message: 'Expected to not find matching entry via _excludes',
+              expectedExclusion,
+            },
+          };
+        }
+      }
+
+      continue;
+    }
+
     const actualValue = actual[key];
     const subDifference = findDifference(keyPath, actualValue, expectedValue);
 
@@ -187,7 +220,7 @@ function makeComparison(name, actualResult, expectedResult) {
  * @param {LocalConsole} localConsole
  * @param {LH.Result} lhr
  * @param {Smokehouse.ExpectedRunnerResult} expected
- * @param {{isBundled?: boolean}=} reportOptions
+ * @param {{runner?: string, isBundled?: boolean}=} reportOptions
  */
 function pruneExpectations(localConsole, lhr, expected, reportOptions) {
   const isFraggleRock = lhr.configSettings.channel === 'fraggle-rock-cli';
@@ -217,8 +250,20 @@ function pruneExpectations(localConsole, lhr, expected, reportOptions) {
    * @param {*} obj
    */
   function pruneRecursively(obj) {
-    for (const key of Object.keys(obj)) {
-      const value = obj[key];
+    /**
+     * @param {string} key
+     */
+    const remove = (key) => {
+      if (Array.isArray(obj)) {
+        obj.splice(Number(key), 1);
+      } else {
+        delete obj[key];
+      }
+    };
+
+    // Because we may be deleting keys, we should iterate the keys backwards
+    // otherwise arrays with multiple pruning checks will skip elements.
+    for (const [key, value] of Object.entries(obj).reverse()) {
       if (!value || typeof value !== 'object') {
         continue;
       }
@@ -229,42 +274,32 @@ function pruneExpectations(localConsole, lhr, expected, reportOptions) {
           JSON.stringify(value, null, 2),
           `Actual Chromium version: ${getChromeVersion()}`,
         ].join(' '));
-        if (Array.isArray(obj)) {
-          obj.splice(Number(key), 1);
-        } else {
-          delete obj[key];
-        }
+        remove(key);
       } else if (value._legacyOnly && isFraggleRock) {
         localConsole.log([
           `[${key}] marked legacy only but run is Fraggle Rock, pruning expectation:`,
           JSON.stringify(value, null, 2),
         ].join(' '));
-        if (Array.isArray(obj)) {
-          obj.splice(Number(key), 1);
-        } else {
-          delete obj[key];
-        }
+        remove(key);
       } else if (value._fraggleRockOnly && !isFraggleRock) {
         localConsole.log([
           `[${key}] marked Fraggle Rock only but run is legacy, pruning expectation:`,
           JSON.stringify(value, null, 2),
           `Actual channel: ${lhr.configSettings.channel}`,
         ].join(' '));
-        if (Array.isArray(obj)) {
-          obj.splice(Number(key), 1);
-        } else {
-          delete obj[key];
-        }
+        remove(key);
       } else if (value._skipInBundled && !isBundled) {
         localConsole.log([
           `[${key}] marked as skip in bundled and runner is bundled, pruning expectation:`,
           JSON.stringify(value, null, 2),
         ].join(' '));
-        if (Array.isArray(obj)) {
-          obj.splice(Number(key), 1);
-        } else {
-          delete obj[key];
-        }
+        remove(key);
+      } else if (value._runner && reportOptions?.runner !== value._runner) {
+        localConsole.log([
+          `[${key}] is only for runner ${value._runner}, pruning expectation:`,
+          JSON.stringify(value, null, 2),
+        ].join(' '));
+        remove(key);
       } else {
         pruneRecursively(value);
       }
@@ -275,6 +310,7 @@ function pruneExpectations(localConsole, lhr, expected, reportOptions) {
     delete obj._skipInBundled;
     delete obj._minChromiumMilestone;
     delete obj._maxChromiumMilestone;
+    delete obj._runner;
   }
 
   const cloned = cloneDeep(expected);
@@ -420,7 +456,7 @@ function reportAssertion(localConsole, assertion) {
  * summary. Returns count of passed and failed tests.
  * @param {{lhr: LH.Result, artifacts: LH.Artifacts, networkRequests?: string[]}} actual
  * @param {Smokehouse.ExpectedRunnerResult} expected
- * @param {{isDebug?: boolean, isBundled?: boolean}=} reportOptions
+ * @param {{runner?: string, isDebug?: boolean, isBundled?: boolean}=} reportOptions
  * @return {{passed: number, failed: number, log: string}}
  */
 function getAssertionReport(actual, expected, reportOptions = {}) {

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

@@ -57,7 +57,7 @@ async function runSmokehouse(smokeTestDefns, smokehouseOptions) {
     useFraggleRock,
     jobs = DEFAULT_CONCURRENT_RUNS,
     retries = DEFAULT_RETRIES,
-    lighthouseRunner = cliLighthouseRunner,
+    lighthouseRunner = Object.assign(cliLighthouseRunner, {runnerName: 'cli'}),
     takeNetworkRequestUrls,
   } = smokehouseOptions;
   assertPositiveInteger('jobs', jobs);
@@ -159,7 +159,10 @@ async function runSmokeTest(smokeTestDefn, testOptions) {
     }
 
     // Assert result.
-    report = getAssertionReport(result, expectations, {isDebug});
+    report = getAssertionReport(result, expectations, {
+      runner: lighthouseRunner.runnerName,
+      isDebug,
+    });
 
     runs.push({
       ...result,

package/lighthouse-core/audits/dobetterweb/inspector-issues.js

@@ -71,19 +71,19 @@ class IssuesPanelEntries extends Audit {
   }
 
   /**
-   * @param {Array<LH.Crdp.Audits.SameSiteCookieIssueDetails>} sameSiteCookieIssues
+   * @param {Array<LH.Crdp.Audits.CookieIssueDetails>} CookieIssues
    * @return {LH.Audit.Details.TableItem}
    */
-  static getSameSiteCookieRow(sameSiteCookieIssues) {
+  static getCookieRow(CookieIssues) {
     const requestUrls = new Set();
-    for (const issue of sameSiteCookieIssues) {
+    for (const issue of CookieIssues) {
       const requestUrl = (issue.request?.url) || issue.cookieUrl;
       if (requestUrl) {
         requestUrls.add(requestUrl);
       }
     }
     return {
-      issueType: 'SameSite cookie',
+      issueType: 'Cookie',
       subItems: {
         type: 'subitems',
         items: Array.from(requestUrls).map(url => {
@@ -164,8 +164,8 @@ class IssuesPanelEntries extends Audit {
     if (issues.mixedContentIssue.length) {
       items.push(this.getMixedContentRow(issues.mixedContentIssue));
     }
-    if (issues.sameSiteCookieIssue.length) {
-      items.push(this.getSameSiteCookieRow(issues.sameSiteCookieIssue));
+    if (issues.cookieIssue.length) {
+      items.push(this.getCookieRow(issues.cookieIssue));
     }
     if (issues.blockedByResponseIssue.length) {
       items.push(this.getBlockedByResponseRow(issues.blockedByResponseIssue));

package/lighthouse-core/audits/script-treemap-data.js

@@ -197,7 +197,7 @@ class ScriptTreemapDataAudit extends Audit {
 
         nodes.push({
           name,
-          resourceBytes: scriptElement.src.length,
+          resourceBytes: scriptElement.content?.length || 0,
         });
         continue;
       }

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

@@ -6,7 +6,7 @@
 'use strict';
 
 const path = require('path');
-const isDeepEqual = require('lodash.isequal');
+const {isEqual: isDeepEqual} = require('lodash');
 const constants = require('./constants.js');
 const Budget = require('./budget.js');
 const ConfigPlugin = require('./config-plugin.js');

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

@@ -5,22 +5,73 @@
  */
 'use strict';
 
-const {snapshot} = require('./gather/snapshot-runner.js');
-const {startTimespan} = require('./gather/timespan-runner.js');
-const {navigation} = require('./gather/navigation-runner.js');
-const UserFlow = require('./user-flow.js');
+const {UserFlow, auditGatherSteps} = require('./user-flow.js');
+const {snapshotGather} = require('./gather/snapshot-runner.js');
+const {startTimespanGather} = require('./gather/timespan-runner.js');
+const {navigationGather} = require('./gather/navigation-runner.js');
+const {generateFlowReportHtml} = require('../../report/generator/report-generator.js');
+const Runner = require('../runner.js');
 
 /**
  * @param {import('puppeteer').Page} page
- * @param {UserFlow.UserFlowOptions} [options]
+ * @param {ConstructorParameters<LH.UserFlow>[1]} [options]
  */
 async function startFlow(page, options) {
   return new UserFlow(page, options);
 }
 
+/**
+ * @param  {Parameters<navigationGather>} params
+ * @return {Promise<LH.RunnerResult|undefined>}
+ */
+async function navigation(...params) {
+  const gatherResult = await navigationGather(...params);
+  return Runner.audit(gatherResult.artifacts, gatherResult.runnerOptions);
+}
+
+/**
+ * @param  {Parameters<snapshotGather>} params
+ * @return {Promise<LH.RunnerResult|undefined>}
+ */
+async function snapshot(...params) {
+  const gatherResult = await snapshotGather(...params);
+  return Runner.audit(gatherResult.artifacts, gatherResult.runnerOptions);
+}
+
+/**
+ * @param  {Parameters<startTimespanGather>} params
+ * @return {Promise<{endTimespan: () => Promise<LH.RunnerResult|undefined>}>}
+ */
+async function startTimespan(...params) {
+  const {endTimespanGather} = await startTimespanGather(...params);
+  const endTimespan = async () => {
+    const gatherResult = await endTimespanGather();
+    return Runner.audit(gatherResult.artifacts, gatherResult.runnerOptions);
+  };
+  return {endTimespan};
+}
+
+/**
+ * @param {LH.FlowResult} flowResult
+ */
+async function generateFlowReport(flowResult) {
+  return generateFlowReportHtml(flowResult);
+}
+
+/**
+ * @param {LH.UserFlow.FlowArtifacts} flowArtifacts
+ * @param {LH.Config.Json} [config]
+ */
+async function auditFlowArtifacts(flowArtifacts, config) {
+  const {gatherSteps, name} = flowArtifacts;
+  return await auditGatherSteps(gatherSteps, {name, config});
+}
+
 module.exports = {
   snapshot,
   startTimespan,
   navigation,
   startFlow,
+  generateFlowReport,
+  auditFlowArtifacts,
 };

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

@@ -30,7 +30,7 @@ const {
 } = require('../../config/config-helpers.js');
 const defaultConfigPath = path.join(__dirname, './default-config.js');
 
-/** @typedef {Omit<LH.Config.FRContext, 'gatherMode'> & {gatherMode: LH.Gatherer.GatherMode}} ConfigContext */
+/** @typedef {LH.Config.FRContext & {gatherMode: LH.Gatherer.GatherMode}} ConfigContext */
 
 /**
  * @param {LH.Config.Json|undefined} configJSON

package/lighthouse-core/fraggle-rock/gather/base-artifacts.js

@@ -6,7 +6,7 @@
 'use strict';
 
 const log = require('lighthouse-logger');
-const isEqual = require('lodash.isequal');
+const {isEqual} = require('lodash');
 const {
   getBrowserVersion,
   getBenchmarkIndex,

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

@@ -210,6 +210,7 @@ async function _computeNavigationResult(
 async function _navigation(navigationContext) {
   const artifactState = getEmptyArtifactState();
   const phaseState = {
+    url: await navigationContext.driver.url(),
     gatherMode: /** @type {const} */ ('navigation'),
     driver: navigationContext.driver,
     computedCache: navigationContext.computedCache,
@@ -223,6 +224,7 @@ async function _navigation(navigationContext) {
   await collectPhaseArtifacts({phase: 'startInstrumentation', ...phaseState});
   await collectPhaseArtifacts({phase: 'startSensitiveInstrumentation', ...phaseState});
   const navigateResult = await _navigate(navigationContext);
+  phaseState.url = navigateResult.finalUrl;
   await collectPhaseArtifacts({phase: 'stopSensitiveInstrumentation', ...phaseState});
   await collectPhaseArtifacts({phase: 'stopInstrumentation', ...phaseState});
   await _cleanupNavigation(navigationContext);
@@ -288,10 +290,12 @@ async function _cleanup({requestedUrl, driver, config}) {
 /**
  * @param {LH.NavigationRequestor} requestor
  * @param {{page: import('puppeteer').Page, config?: LH.Config.Json, configContext?: LH.Config.FRContext}} options
- * @return {Promise<LH.RunnerResult|undefined>}
+ * @return {Promise<LH.Gatherer.FRGatherResult>}
  */
-async function navigation(requestor, options) {
+async function navigationGather(requestor, options) {
   const {page, configContext = {}} = options;
+  log.setLevel(configContext.logLevel || 'error');
+
   const {config} = initializeConfig(options.config, {...configContext, gatherMode: 'navigation'});
   const computedCache = new Map();
   const internalOptions = {
@@ -321,11 +325,11 @@ async function navigation(requestor, options) {
     },
     runnerOptions
   );
-  return Runner.audit(artifacts, runnerOptions);
+  return {artifacts, runnerOptions};
 }
 
 module.exports = {
-  navigation,
+  navigationGather,
   _setup,
   _setupNavigation,
   _navigate,

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

@@ -15,6 +15,7 @@
  * @property {LH.Gatherer.GatherMode} gatherMode
  * @property {Map<string, LH.ArbitraryEqualityMap>} computedCache
  * @property {LH.Config.Settings} settings
+ * @property {string} url
  */
 
 /** @typedef {Record<string, Promise<any>>} IntermediateArtifacts */
@@ -74,6 +75,7 @@ async function collectPhaseArtifacts(options) {
     gatherMode,
     computedCache,
     settings,
+    url,
   } = options;
   const priorPhase = phaseToPriorPhase[phase];
   const priorPhaseArtifacts = (priorPhase && artifactState[priorPhase]) || {};
@@ -90,7 +92,7 @@ async function collectPhaseArtifacts(options) {
         : /** @type {Dependencies} */ ({});
 
       return gatherer[phase]({
-        url: await driver.url(),
+        url,
         gatherMode,
         driver,
         baseArtifacts,

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

@@ -5,6 +5,7 @@
  */
 'use strict';
 
+const log = require('lighthouse-logger');
 const Driver = require('./driver.js');
 const Runner = require('../../runner.js');
 const {
@@ -15,16 +16,21 @@ const {
 const {initializeConfig} = require('../config/config.js');
 const {getBaseArtifacts, finalizeArtifacts} = require('./base-artifacts.js');
 
-/** @param {{page: import('puppeteer').Page, config?: LH.Config.Json, configContext?: LH.Config.FRContext}} options */
-async function snapshot(options) {
+/**
+ * @param {{page: import('puppeteer').Page, config?: LH.Config.Json, configContext?: LH.Config.FRContext}} options
+ * @return {Promise<LH.Gatherer.FRGatherResult>}
+ */
+async function snapshotGather(options) {
   const {configContext = {}} = options;
+  log.setLevel(configContext.logLevel || 'error');
+
   const {config} = initializeConfig(options.config, {...configContext, gatherMode: 'snapshot'});
   const driver = new Driver(options.page);
   await driver.connect();
 
   /** @type {Map<string, LH.ArbitraryEqualityMap>} */
   const computedCache = new Map();
-  const url = await options.page.url();
+  const url = await driver.url();
 
   const runnerOptions = {config, computedCache};
   const artifacts = await Runner.gather(
@@ -36,6 +42,7 @@ async function snapshot(options) {
       const artifactDefinitions = config.artifacts || [];
       const artifactState = getEmptyArtifactState();
       await collectPhaseArtifacts({
+        url,
         phase: 'getArtifact',
         gatherMode: 'snapshot',
         driver,
@@ -53,9 +60,9 @@ async function snapshot(options) {
     },
     runnerOptions
   );
-  return Runner.audit(artifacts, runnerOptions);
+  return {artifacts, runnerOptions};
 }
 
 module.exports = {
-  snapshot,
+  snapshotGather,
 };