lighthouse 11.2.0-dev.20231017 → 11.2.0-dev.20231019

package/core/gather/navigation-runner.js

@@ -14,7 +14,6 @@ import * as prepare from './driver/prepare.js';
 import {gotoURL} from './driver/navigation.js';
 import * as storage from './driver/storage.js';
 import * as emulation from '../lib/emulation.js';
-import {defaultNavigationConfig} from '../config/constants.js';
 import {initializeConfig} from '../config/config.js';
 import {getBaseArtifacts, finalizeArtifacts} from './base-artifacts.js';
 import * as format from '../../shared/localization/format.js';
@@ -30,7 +29,6 @@ import {NetworkRecords} from '../computed/network-records.js';
  * @property {Driver} driver
  * @property {LH.Puppeteer.Page} page
  * @property {LH.Config.ResolvedConfig} resolvedConfig
- * @property {LH.Config.NavigationDefn} navigation
  * @property {LH.NavigationRequestor} requestor
  * @property {LH.BaseArtifacts} baseArtifacts
  * @property {Map<string, LH.ArbitraryEqualityMap>} computedCache
@@ -50,36 +48,23 @@ async function _setup({driver, resolvedConfig, requestor}) {
 
   // We can't trigger the navigation through user interaction if we reset the page before starting.
   if (typeof requestor === 'string' && !resolvedConfig.settings.skipAboutBlank) {
-    await gotoURL(driver, defaultNavigationConfig.blankPage, {waitUntil: ['navigated']});
+    // Disable network monitor on the blank page to prevent it from picking up network requests and
+    // frame navigated events before the run starts.
+    await driver._networkMonitor?.disable();
+
+    await gotoURL(driver, resolvedConfig.settings.blankPage, {waitUntil: ['navigated']});
+
+    await driver._networkMonitor?.enable();
   }
 
   const baseArtifacts = await getBaseArtifacts(resolvedConfig, driver, {gatherMode: 'navigation'});
 
-  await prepare.prepareTargetForNavigationMode(driver, resolvedConfig.settings);
-
-  return {baseArtifacts};
-}
+  const {warnings} =
+    await prepare.prepareTargetForNavigationMode(driver, resolvedConfig.settings, requestor);
 
-/**
- * @param {NavigationContext} navigationContext
- * @return {Promise<{warnings: Array<LH.IcuMessage>}>}
- */
-async function _setupNavigation({requestor, driver, navigation, resolvedConfig}) {
-  // We can't trigger the navigation through user interaction if we reset the page before starting.
-  if (typeof requestor === 'string' && !resolvedConfig.settings.skipAboutBlank) {
-    await gotoURL(driver, navigation.blankPage, {...navigation, waitUntil: ['navigated']});
-  }
+  baseArtifacts.LighthouseRunWarnings.push(...warnings);
 
-  const {warnings} = await prepare.prepareTargetForIndividualNavigation(
-    driver.defaultSession,
-    resolvedConfig.settings,
-    {
-      ...navigation,
-      requestor,
-    }
-  );
-
-  return {warnings};
+  return {baseArtifacts};
 }
 
 /**
@@ -91,20 +76,20 @@ async function _cleanupNavigation({driver}) {
 
 /**
  * @param {NavigationContext} navigationContext
- * @return {Promise<{requestedUrl: string, mainDocumentUrl: string, navigationError: LH.LighthouseError | undefined, warnings: Array<LH.IcuMessage>}>}
+ * @return {Promise<{requestedUrl: string, mainDocumentUrl: string, navigationError: LH.LighthouseError | undefined}>}
  */
 async function _navigate(navigationContext) {
   const {driver, resolvedConfig, requestor} = navigationContext;
 
   try {
     const {requestedUrl, mainDocumentUrl, warnings} = await gotoURL(driver, requestor, {
-      ...navigationContext.navigation,
-      debugNavigation: resolvedConfig.settings.debugNavigation,
-      maxWaitForFcp: resolvedConfig.settings.maxWaitForFcp,
-      maxWaitForLoad: resolvedConfig.settings.maxWaitForLoad,
-      waitUntil: navigationContext.navigation.pauseAfterFcpMs ? ['fcp', 'load'] : ['load'],
+      ...resolvedConfig.settings,
+      waitUntil: resolvedConfig.settings.pauseAfterFcpMs ? ['fcp', 'load'] : ['load'],
     });
-    return {requestedUrl, mainDocumentUrl, navigationError: undefined, warnings};
+
+    navigationContext.baseArtifacts.LighthouseRunWarnings.push(...warnings);
+
+    return {requestedUrl, mainDocumentUrl, navigationError: undefined};
   } catch (err) {
     if (!(err instanceof LighthouseError)) throw err;
     if (err.code !== 'NO_FCP' && err.code !== 'PAGE_HUNG') throw err;
@@ -115,7 +100,6 @@ async function _navigate(navigationContext) {
       requestedUrl: requestor,
       mainDocumentUrl: requestor,
       navigationError: err,
-      warnings: [],
     };
   }
 }
@@ -158,36 +142,32 @@ async function _collectDebugData(navigationContext, phaseState) {
 /**
  * @param {NavigationContext} navigationContext
  * @param {PhaseState} phaseState
- * @param {Awaited<ReturnType<typeof _setupNavigation>>} setupResult
  * @param {Awaited<ReturnType<typeof _navigate>>} navigateResult
- * @return {Promise<{artifacts: Partial<LH.GathererArtifacts>, warnings: Array<LH.IcuMessage>, pageLoadError: LH.LighthouseError | undefined}>}
+ * @return {Promise<Partial<LH.GathererArtifacts>>}
  */
 async function _computeNavigationResult(
   navigationContext,
   phaseState,
-  setupResult,
   navigateResult
 ) {
-  const {navigationError, mainDocumentUrl} = navigateResult;
-  const warnings = [...setupResult.warnings, ...navigateResult.warnings];
+  const {navigationError, requestedUrl, mainDocumentUrl} = navigateResult;
   const debugData = await _collectDebugData(navigationContext, phaseState);
   const pageLoadError = debugData.records
     ? getPageLoadError(navigationError, {
       url: mainDocumentUrl,
-      loadFailureMode: navigationContext.navigation.loadFailureMode,
       networkRecords: debugData.records,
-      warnings,
+      warnings: navigationContext.baseArtifacts.LighthouseRunWarnings,
     })
     : navigationError;
 
   if (pageLoadError) {
     const locale = navigationContext.resolvedConfig.settings.locale;
     const localizedMessage = format.getFormatted(pageLoadError.friendlyMessage, locale);
-    log.error('NavigationRunner', localizedMessage, navigateResult.requestedUrl);
+    log.error('NavigationRunner', localizedMessage, requestedUrl);
 
     /** @type {Partial<LH.GathererArtifacts>} */
     const artifacts = {};
-    const pageLoadErrorId = `pageLoadError-${navigationContext.navigation.id}`;
+    const pageLoadErrorId = 'pageLoadError-defaultPass';
     if (debugData.devtoolsLog) {
       artifacts.DevtoolsLogError = debugData.devtoolsLog;
       artifacts.devtoolsLogs = {[pageLoadErrorId]: debugData.devtoolsLog};
@@ -197,20 +177,14 @@ async function _computeNavigationResult(
       artifacts.traces = {[pageLoadErrorId]: debugData.trace};
     }
 
-    return {
-      pageLoadError,
-      artifacts,
-      warnings: [...warnings, pageLoadError.friendlyMessage],
-    };
+    navigationContext.baseArtifacts.LighthouseRunWarnings.push(pageLoadError.friendlyMessage);
+    navigationContext.baseArtifacts.PageLoadError = pageLoadError;
+
+    return artifacts;
   } else {
     await collectPhaseArtifacts({phase: 'getArtifact', ...phaseState});
 
-    const artifacts = await awaitArtifacts(phaseState.artifactState);
-    return {
-      artifacts,
-      warnings,
-      pageLoadError: undefined,
-    };
+    return await awaitArtifacts(phaseState.artifactState);
   }
 }
 
@@ -219,6 +193,10 @@ async function _computeNavigationResult(
  * @return {ReturnType<typeof _computeNavigationResult>}
  */
 async function _navigation(navigationContext) {
+  if (!navigationContext.resolvedConfig.artifacts) {
+    throw new Error('No artifacts were defined on the config');
+  }
+
   const artifactState = getEmptyArtifactState();
   const phaseState = {
     url: await navigationContext.driver.url(),
@@ -226,14 +204,12 @@ async function _navigation(navigationContext) {
     driver: navigationContext.driver,
     page: navigationContext.page,
     computedCache: navigationContext.computedCache,
-    artifactDefinitions: navigationContext.navigation.artifacts,
+    artifactDefinitions: navigationContext.resolvedConfig.artifacts,
     artifactState,
     baseArtifacts: navigationContext.baseArtifacts,
     settings: navigationContext.resolvedConfig.settings,
   };
 
-  const setupResult = await _setupNavigation(navigationContext);
-
   const disableAsyncStacks =
     await prepare.enableAsyncStacks(navigationContext.driver.defaultSession);
 
@@ -262,58 +238,7 @@ async function _navigation(navigationContext) {
 
   await _cleanupNavigation(navigationContext);
 
-  return _computeNavigationResult(navigationContext, phaseState, setupResult, navigateResult);
-}
-
-/**
- * @param {{driver: Driver, page: LH.Puppeteer.Page, resolvedConfig: LH.Config.ResolvedConfig, requestor: LH.NavigationRequestor; baseArtifacts: LH.BaseArtifacts, computedCache: NavigationContext['computedCache']}} args
- * @return {Promise<{artifacts: Partial<LH.Artifacts & LH.BaseArtifacts>}>}
- */
-async function _navigations(args) {
-  const {
-    driver,
-    page,
-    resolvedConfig,
-    requestor,
-    baseArtifacts,
-    computedCache,
-  } = args;
-
-  if (!resolvedConfig.artifacts || !resolvedConfig.navigations) {
-    throw new Error('No artifacts were defined on the config');
-  }
-
-  /** @type {Partial<LH.Artifacts & LH.BaseArtifacts>} */
-  const artifacts = {};
-  /** @type {Array<LH.IcuMessage>} */
-  const LighthouseRunWarnings = [];
-
-  for (const navigation of resolvedConfig.navigations) {
-    const navigationContext = {
-      driver,
-      page,
-      navigation,
-      requestor,
-      resolvedConfig,
-      baseArtifacts,
-      computedCache,
-    };
-
-    let shouldHaltNavigations = false;
-    const navigationResult = await _navigation(navigationContext);
-    if (navigation.loadFailureMode === 'fatal') {
-      if (navigationResult.pageLoadError) {
-        artifacts.PageLoadError = navigationResult.pageLoadError;
-        shouldHaltNavigations = true;
-      }
-    }
-
-    LighthouseRunWarnings.push(...navigationResult.warnings);
-    Object.assign(artifacts, navigationResult.artifacts);
-    if (shouldHaltNavigations) break;
-  }
-
-  return {artifacts: {...artifacts, LighthouseRunWarnings}};
+  return _computeNavigationResult(navigationContext, phaseState, navigateResult);
 }
 
 /**
@@ -369,11 +294,15 @@ async function navigationGather(page, requestor, options = {}) {
         driver,
         lhBrowser,
         lhPage,
+        page,
         resolvedConfig,
         requestor: normalizedRequestor,
+        computedCache: new Map(),
       };
       const {baseArtifacts} = await _setup(context);
-      const {artifacts} = await _navigations({...context, page, baseArtifacts, computedCache});
+
+      const artifacts = await _navigation({...context, baseArtifacts});
+
       await _cleanup(context);
 
       return finalizeArtifacts(baseArtifacts, artifacts);
@@ -386,9 +315,7 @@ async function navigationGather(page, requestor, options = {}) {
 export {
   navigationGather,
   _setup,
-  _setupNavigation,
   _navigate,
   _navigation,
-  _navigations,
   _cleanup,
 };

package/core/lib/navigation-error.d.ts

@@ -15,12 +15,11 @@ export function getInterstitialError(mainRecord: LH.Artifacts.NetworkRequest | u
  * Returns an error if the page load should be considered failed, e.g. from a
  * main document request failure, a security issue, etc.
  * @param {LH.LighthouseError|undefined} navigationError
- * @param {{url: string, loadFailureMode: LH.Config.SharedPassNavigationJson['loadFailureMode'], networkRecords: Array<LH.Artifacts.NetworkRequest>, warnings: Array<string | LH.IcuMessage>}} context
+ * @param {{url: string, networkRecords: Array<LH.Artifacts.NetworkRequest>, warnings: Array<string | LH.IcuMessage>}} context
  * @return {LH.LighthouseError|undefined}
  */
 export function getPageLoadError(navigationError: LH.LighthouseError | undefined, context: {
     url: string;
-    loadFailureMode: LH.Config.SharedPassNavigationJson['loadFailureMode'];
     networkRecords: Array<LH.Artifacts.NetworkRequest>;
     warnings: Array<string | LH.IcuMessage>;
 }): LH.LighthouseError | undefined;

package/core/lib/navigation-error.js

@@ -113,11 +113,11 @@ function getNonHtmlError(finalRecord) {
  * Returns an error if the page load should be considered failed, e.g. from a
  * main document request failure, a security issue, etc.
  * @param {LH.LighthouseError|undefined} navigationError
- * @param {{url: string, loadFailureMode: LH.Config.SharedPassNavigationJson['loadFailureMode'], networkRecords: Array<LH.Artifacts.NetworkRequest>, warnings: Array<string | LH.IcuMessage>}} context
+ * @param {{url: string, networkRecords: Array<LH.Artifacts.NetworkRequest>, warnings: Array<string | LH.IcuMessage>}} context
  * @return {LH.LighthouseError|undefined}
  */
 function getPageLoadError(navigationError, context) {
-  const {url, loadFailureMode, networkRecords} = context;
+  const {url, networkRecords} = context;
   /** @type {LH.Artifacts.NetworkRequest|undefined} */
   let mainRecord = NetworkAnalyzer.findResourceForUrl(networkRecords, url);
 
@@ -148,10 +148,6 @@ function getPageLoadError(navigationError, context) {
   const interstitialError = getInterstitialError(mainRecord, networkRecords);
   const nonHtmlError = getNonHtmlError(finalRecord);
 
-  // Check to see if we need to ignore the page load failure.
-  // e.g. When the driver is offline, the load will fail without page offline support.
-  if (loadFailureMode === 'ignore') return;
-
   // We want to special-case the interstitial beyond FAILED_DOCUMENT_REQUEST. See https://github.com/GoogleChrome/lighthouse/pull/8865#issuecomment-497507618
   if (interstitialError) return interstitialError;