lighthouse 9.6.8 → 10.0.0

package/cli/test/smokehouse/core-tests.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.
+ */
+
+import a11y from './test-definitions/a11y.js';
+import byteEfficiency from './test-definitions/byte-efficiency.js';
+import byteGzip from './test-definitions/byte-gzip.js';
+import cspAllowAll from './test-definitions/csp-allow-all.js';
+import cspBlockAll from './test-definitions/csp-block-all.js';
+import dbw from './test-definitions/dobetterweb.js';
+import errorsExpiredSsl from './test-definitions/errors-expired-ssl.js';
+import errorsIframeExpiredSsl from './test-definitions/errors-iframe-expired-ssl.js';
+import errorsInfiniteLoop from './test-definitions/errors-infinite-loop.js';
+import formsAutoComplete from './test-definitions/forms-autocomplete.js';
+import fpsMax from './test-definitions/fps-max.js';
+import fpsMaxPassive from './test-definitions/fps-max-passive.js';
+import fpsScaled from './test-definitions/fps-scaled.js';
+import issuesMixedContent from './test-definitions/issues-mixed-content.js';
+import lanternFetch from './test-definitions/lantern-fetch.js';
+import lanternIdleCallbackLong from './test-definitions/lantern-idle-callback-long.js';
+import lanternIdleCallbackShort from './test-definitions/lantern-idle-callback-short.js';
+import lanternOnline from './test-definitions/lantern-online.js';
+import lanternSetTimeout from './test-definitions/lantern-set-timeout.js';
+import lanternXhr from './test-definitions/lantern-xhr.js';
+import legacyJavascript from './test-definitions/legacy-javascript.js';
+import metricsDebugger from './test-definitions/metrics-debugger.js';
+import metricsDelayedFcp from './test-definitions/metrics-delayed-fcp.js';
+import metricsDelayedLcp from './test-definitions/metrics-delayed-lcp.js';
+import metricsTrickyTti from './test-definitions/metrics-tricky-tti.js';
+import metricsTrickyTtiLateFcp from './test-definitions/metrics-tricky-tti-late-fcp.js';
+import offlineOnlineOnly from './test-definitions/offline-online-only.js';
+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';
+import perfDiagnosticsThirdParty from './test-definitions/perf-diagnostics-third-party.js';
+import perfDiagnosticsUnsizedImages from './test-definitions/perf-diagnostics-unsized-images.js';
+import perfFonts from './test-definitions/perf-fonts.js';
+import perfFrameMetrics from './test-definitions/perf-frame-metrics.js';
+import perfPreload from './test-definitions/perf-preload.js';
+import perfTraceElements from './test-definitions/perf-trace-elements.js';
+import pubads from './test-definitions/pubads.js';
+import pwaAirhorner from './test-definitions/pwa-airhorner.js';
+import pwaCaltrain from './test-definitions/pwa-caltrain.js';
+import pwaChromestatus from './test-definitions/pwa-chromestatus.js';
+import pwaRocks from './test-definitions/pwa-rocks.js';
+import pwaSvgomg from './test-definitions/pwa-svgomg.js';
+import redirectsClientPaintServer from './test-definitions/redirects-client-paint-server.js';
+import redirectsHistoryPushState from './test-definitions/redirects-history-push-state.js';
+import redirectsMultipleServer from './test-definitions/redirects-multiple-server.js';
+import redirectsScripts from './test-definitions/redirects-scripts.js';
+import redirectsSelf from './test-definitions/redirects-self.js';
+import redirectsSingleClient from './test-definitions/redirects-single-client.js';
+import redirectsSingleServer from './test-definitions/redirects-single-server.js';
+import screenshot from './test-definitions/screenshot.js';
+import seoFailing from './test-definitions/seo-failing.js';
+import seoPassing from './test-definitions/seo-passing.js';
+import seoStatus403 from './test-definitions/seo-status-403.js';
+import seoTapTargets from './test-definitions/seo-tap-targets.js';
+import sourceMaps from './test-definitions/source-maps.js';
+import timing from './test-definitions/timing.js';
+
+/** @type {ReadonlyArray<Smokehouse.TestDfn>} */
+const smokeTests = [
+  a11y,
+  byteEfficiency,
+  byteGzip,
+  cspAllowAll,
+  cspBlockAll,
+  dbw,
+  errorsExpiredSsl,
+  errorsIframeExpiredSsl,
+  errorsInfiniteLoop,
+  formsAutoComplete,
+  fpsMax,
+  fpsScaled,
+  fpsMaxPassive,
+  issuesMixedContent,
+  lanternFetch,
+  lanternIdleCallbackLong,
+  lanternIdleCallbackShort,
+  lanternOnline,
+  lanternSetTimeout,
+  lanternXhr,
+  legacyJavascript,
+  metricsDebugger,
+  metricsDelayedFcp,
+  metricsDelayedLcp,
+  metricsTrickyTti,
+  metricsTrickyTtiLateFcp,
+  offlineOnlineOnly,
+  offlineReady,
+  offlineSwBroken,
+  offlineSwSlow,
+  oopifRequests,
+  oopifScripts,
+  perfBudgets,
+  perfDebug,
+  perfDiagnosticsAnimations,
+  perfDiagnosticsThirdParty,
+  perfDiagnosticsUnsizedImages,
+  perfFonts,
+  perfFrameMetrics,
+  perfPreload,
+  perfTraceElements,
+  pubads,
+  pwaAirhorner,
+  pwaCaltrain,
+  pwaChromestatus,
+  pwaRocks,
+  pwaSvgomg,
+  redirectsClientPaintServer,
+  redirectsHistoryPushState,
+  redirectsMultipleServer,
+  redirectsScripts,
+  redirectsSelf,
+  redirectsSingleClient,
+  redirectsSingleServer,
+  screenshot,
+  seoFailing,
+  seoPassing,
+  seoStatus403,
+  seoTapTargets,
+  sourceMaps,
+  timing,
+];
+
+export default smokeTests;

package/cli/test/smokehouse/frontends/back-compat-util.d.ts

@@ -0,0 +1,16 @@
+/**
+ * @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.
+ */
+/**
+ * COMPAT: update from the old TestDefn format (array of `expectations` per
+ * definition) to the new format (single `expectations` per def), doing our best
+ * generating some unique IDs.
+ * TODO: remove in Lighthouse 9+ once PubAds (and others?) are updated.
+ * @see https://github.com/GoogleChrome/lighthouse/issues/11950
+ * @param {ReadonlyArray<Smokehouse.BackCompatTestDefn>} allTestDefns
+ * @return {Array<Smokehouse.TestDfn>}
+ */
+export function updateTestDefnFormat(allTestDefns: ReadonlyArray<Smokehouse.BackCompatTestDefn>): Array<Smokehouse.TestDfn>;
+//# sourceMappingURL=back-compat-util.d.ts.map

package/cli/test/smokehouse/frontends/back-compat-util.js

@@ -0,0 +1,41 @@
+/**
+ * @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.
+ */
+
+/**
+ * COMPAT: update from the old TestDefn format (array of `expectations` per
+ * definition) to the new format (single `expectations` per def), doing our best
+ * generating some unique IDs.
+ * TODO: remove in Lighthouse 9+ once PubAds (and others?) are updated.
+ * @see https://github.com/GoogleChrome/lighthouse/issues/11950
+ * @param {ReadonlyArray<Smokehouse.BackCompatTestDefn>} allTestDefns
+ * @return {Array<Smokehouse.TestDfn>}
+ */
+function updateTestDefnFormat(allTestDefns) {
+  const expandedTestDefns = allTestDefns.map(testDefn => {
+    if (Array.isArray(testDefn.expectations)) {
+      // Create a testDefn per expectation.
+      return testDefn.expectations.map((expectations, index) => {
+        return {
+          ...testDefn,
+          id: `${testDefn.id}-${index}`,
+          expectations,
+        };
+      });
+    } else {
+      // New object to make tsc happy.
+      return {
+        ...testDefn,
+        expectations: testDefn.expectations,
+      };
+    }
+  });
+
+  return expandedTestDefns.flat();
+}
+
+export {
+  updateTestDefnFormat,
+};

package/cli/test/smokehouse/frontends/lib.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @param {Smokehouse.SmokehouseLibOptions} options
+ */
+export function smokehouse(options: Smokehouse.SmokehouseLibOptions): Promise<{
+    success: boolean;
+    testResults: import("../smokehouse.js").SmokehouseResult[];
+}>;
+//# sourceMappingURL=lib.d.ts.map

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

@@ -0,0 +1,48 @@
+/**
+ * @license Copyright 2020 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 Smoke test runner.
+ * Used to test integrations that run Lighthouse within a browser (i.e. LR, DevTools)
+ * Supports skipping and modifiying expectations to match the environment.
+ */
+
+/* eslint-disable no-console */
+
+import cloneDeep from 'lodash/cloneDeep.js';
+
+import smokeTests from '../core-tests.js';
+import {runSmokehouse, getShardedDefinitions} from '../smokehouse.js';
+
+/**
+ * @param {Smokehouse.SmokehouseLibOptions} options
+ */
+async function smokehouse(options) {
+  const {urlFilterRegex, skip, modify, shardArg, ...smokehouseOptions} = options;
+
+  const clonedTests = cloneDeep(smokeTests);
+  const modifiedTests = [];
+  for (const test of clonedTests) {
+    if (urlFilterRegex && !test.expectations.lhr.requestedUrl.match(urlFilterRegex)) {
+      continue;
+    }
+
+    const reasonToSkip = skip && skip(test, test.expectations);
+    if (reasonToSkip) {
+      console.log(`skipping ${test.expectations.lhr.requestedUrl}: ${reasonToSkip}`);
+      continue;
+    }
+
+    modify && modify(test, test.expectations);
+    modifiedTests.push(test);
+  }
+
+  const shardedTests = getShardedDefinitions(modifiedTests, shardArg);
+
+  return runSmokehouse(shardedTests, smokehouseOptions);
+}
+
+export {smokehouse};

package/cli/test/smokehouse/frontends/node.d.ts

@@ -0,0 +1,2 @@
+export * from "../smokehouse.js";
+//# sourceMappingURL=node.d.ts.map

package/cli/test/smokehouse/frontends/node.js

@@ -0,0 +1,12 @@
+/**
+ * @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 smokehouse frontend for running within a node process.
+ */
+
+// Smokehouse is runnable from within node, so just a no-op for now.
+export * from '../smokehouse.js';

package/cli/test/smokehouse/frontends/smokehouse-bin.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=smokehouse-bin.d.ts.map

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

@@ -0,0 +1,258 @@
+#!/usr/bin/env node
+/**
+ * @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 smokehouse frontend for running from the command line. Parse
+ * flags, start fixture webservers, then run smokehouse.
+ */
+
+/* eslint-disable no-console */
+
+import path from 'path';
+import fs from 'fs';
+import url from 'url';
+
+import cloneDeep from 'lodash/cloneDeep.js';
+import yargs from 'yargs';
+import * as yargsHelpers from 'yargs/helpers';
+import log from 'lighthouse-logger';
+
+import {runSmokehouse, getShardedDefinitions} from '../smokehouse.js';
+import {updateTestDefnFormat} from './back-compat-util.js';
+import {LH_ROOT} from '../../../../root.js';
+import exclusions from '../config/exclusions.js';
+
+const coreTestDefnsPath =
+  path.join(LH_ROOT, 'cli/test/smokehouse/core-tests.js');
+
+/**
+ * Possible Lighthouse runners. Loaded dynamically so e.g. a CLI run isn't
+ * contingent on having built all the bundles.
+ */
+const runnerPaths = {
+  cli: '../lighthouse-runners/cli.js',
+  bundle: '../lighthouse-runners/bundle.js',
+  devtools: '../lighthouse-runners/devtools.js',
+};
+
+/**
+ * Determine batches of smoketests to run, based on the `requestedIds`.
+ * @param {Array<Smokehouse.TestDfn>} allTestDefns
+ * @param {Array<string>} requestedIds
+ * @param {Set<string>} excludedTests
+ * @return {Array<Smokehouse.TestDfn>}
+ */
+function getDefinitionsToRun(allTestDefns, requestedIds, excludedTests) {
+  let smokes = [];
+  const usage = `    ${log.dim}yarn smoke ${allTestDefns.map(t => t.id).join(' ')}${log.reset}\n`;
+
+  if (requestedIds.length === 0) {
+    smokes = [...allTestDefns];
+    console.log('Running ALL smoketests. Equivalent to:');
+    console.log(usage);
+  } else {
+    smokes = allTestDefns.filter(test => {
+      // Include all tests that *include* requested id.
+      // e.g. a requested 'pwa' will match 'pwa-airhorner', 'pwa-caltrain', etc
+      return requestedIds.some(requestedId => test.id.includes(requestedId));
+    });
+    console.log(`Running ONLY smoketests for: ${smokes.map(t => t.id).join(' ')}\n`);
+  }
+
+  const unmatchedIds = requestedIds.filter(requestedId => {
+    return !allTestDefns.map(t => t.id).some(id => id.includes(requestedId));
+  });
+  if (unmatchedIds.length) {
+    console.log(log.redify(`Smoketests not found for: ${unmatchedIds.join(' ')}`));
+    console.log(`Check test exclusions (${[...excludedTests].join(' ')})\n`);
+    console.log(usage);
+  }
+
+  if (!smokes.length) {
+    throw new Error('no smoketest found to run');
+  }
+
+  return smokes;
+}
+
+/**
+ * Prune the `networkRequests` from the test expectations when `takeNetworkRequestUrls`
+ * is not defined. Custom servers may not have this method available in-process.
+ * Also asserts that any expectation with `networkRequests` is run serially. For core
+ * tests, we don't currently have a good way to map requests to test definitions if
+ * the tests are run in parallel.
+ * @param {Array<Smokehouse.TestDfn>} testDefns
+ * @param {Function|undefined} takeNetworkRequestUrls
+ * @return {Array<Smokehouse.TestDfn>}
+ */
+function pruneExpectedNetworkRequests(testDefns, takeNetworkRequestUrls) {
+  const pruneNetworkRequests = !takeNetworkRequestUrls;
+
+  const clonedDefns = cloneDeep(testDefns);
+  for (const {id, expectations, runSerially} of clonedDefns) {
+    if (!runSerially && expectations.networkRequests) {
+      throw new Error(`'${id}' must be set to 'runSerially: true' to assert 'networkRequests'`);
+    }
+
+    if (pruneNetworkRequests && expectations.networkRequests) {
+      // eslint-disable-next-line max-len
+      const msg = `'networkRequests' cannot be asserted in test '${id}'. They should only be asserted on tests from an in-process server`;
+      if (process.env.CI) {
+        // If we're in CI, we require any networkRequests expectations to be asserted.
+        throw new Error(msg);
+      }
+
+      console.warn(log.redify('Warning:'),
+          `${msg}. Pruning expectation: ${JSON.stringify(expectations.networkRequests)}`);
+      expectations.networkRequests = undefined;
+    }
+  }
+
+  return clonedDefns;
+}
+
+/**
+ * CLI entry point.
+ */
+async function begin() {
+  const y = yargs(yargsHelpers.hideBin(process.argv));
+  const rawArgv = y
+    .help('help')
+    .usage('node $0 [<options>] <test-ids>')
+    .example('node $0 -j=1 pwa seo', 'run pwa and seo tests serially')
+    .option('_', {
+      array: true,
+      type: 'string',
+    })
+    .options({
+      'debug': {
+        type: 'boolean',
+        default: false,
+        describe: 'Save test artifacts and output verbose logs',
+      },
+      'legacy-navigation': {
+        type: 'boolean',
+        default: false,
+        describe: 'Use the legacy navigation runner',
+      },
+      'jobs': {
+        type: 'number',
+        alias: 'j',
+        describe: 'Manually set the number of jobs to run at once. `1` runs all tests serially',
+      },
+      'retries': {
+        type: 'number',
+        describe: 'The number of times to retry failing tests before accepting. Defaults to 0',
+      },
+      'runner': {
+        default: 'cli',
+        choices: ['cli', 'bundle', 'devtools'],
+        describe: 'The method of running Lighthouse',
+      },
+      'tests-path': {
+        type: 'string',
+        describe: 'The path to a set of test definitions to run. Defaults to core smoke tests.',
+      },
+      'shard': {
+        type: 'string',
+        // eslint-disable-next-line max-len
+        describe: 'A argument of the form "n/d", which divides the selected tests into d groups and runs the nth group. n and d must be positive integers with 1 ≤ n ≤ d.',
+      },
+      'ignore-exclusions': {
+        type: 'boolean',
+        default: false,
+        describe: 'Ignore any smoke test exclusions set.',
+      },
+    })
+    .wrap(y.terminalWidth())
+    .argv;
+
+  // Augmenting yargs type with auto-camelCasing breaks in tsc@4.1.2 and @types/yargs@15.0.11,
+  // so for now cast to add yarg's camelCase properties to type.
+  const argv =
+    /** @type {Awaited<typeof rawArgv> & LH.Util.CamelCasify<Awaited<typeof rawArgv>>} */ (rawArgv);
+
+  const jobs = Number.isFinite(argv.jobs) ? argv.jobs : undefined;
+  const retries = Number.isFinite(argv.retries) ? argv.retries : undefined;
+
+  const runnerPath = runnerPaths[/** @type {keyof typeof runnerPaths} */ (argv.runner)];
+  if (argv.runner === 'bundle') {
+    console.log('\n✨ Be sure to have recently run this: yarn build-all');
+  }
+  const {runLighthouse, setup} = await import(runnerPath);
+  runLighthouse.runnerName = argv.runner;
+
+  // Find test definition file and filter by requestedTestIds.
+  let testDefnPath = argv.testsPath || coreTestDefnsPath;
+  testDefnPath = path.resolve(process.cwd(), testDefnPath);
+  const requestedTestIds = argv._;
+  const {default: rawTestDefns} = await import(url.pathToFileURL(testDefnPath).href);
+  const allTestDefns = updateTestDefnFormat(rawTestDefns);
+  const excludedTests = new Set(exclusions[argv.runner] || []);
+  const filteredTestDefns = argv.ignoreExclusions ?
+    allTestDefns : allTestDefns.filter(test => !excludedTests.has(test.id));
+  const requestedTestDefns = getDefinitionsToRun(filteredTestDefns,
+      requestedTestIds, excludedTests);
+  const testDefns = getShardedDefinitions(requestedTestDefns, argv.shard);
+
+  let smokehouseResult;
+  let servers;
+  let takeNetworkRequestUrls = undefined;
+
+  try {
+    // If running the core tests, spin up the test server.
+    if (testDefnPath === coreTestDefnsPath) {
+      const {createServers} = await import('../../fixtures/static-server.js');
+      servers = await createServers();
+      takeNetworkRequestUrls = servers[0].takeRequestUrls.bind(servers[0]);
+    }
+
+    const prunedTestDefns = pruneExpectedNetworkRequests(testDefns, takeNetworkRequestUrls);
+    const options = {
+      jobs,
+      retries,
+      isDebug: argv.debug,
+      useLegacyNavigation: argv.legacyNavigation,
+      lighthouseRunner: runLighthouse,
+      takeNetworkRequestUrls,
+      setup,
+    };
+
+    smokehouseResult = (await runSmokehouse(prunedTestDefns, options));
+  } finally {
+    servers?.forEach(s => s.close());
+  }
+
+  if (!smokehouseResult.success) {
+    const failedTestResults = smokehouseResult.testResults.filter(r => r.failed);
+
+    // For CI, save failed runs to directory to be uploaded.
+    if (process.env.CI) {
+      const failuresDir = `${LH_ROOT}/.tmp/smokehouse-ci-failures`;
+      fs.mkdirSync(failuresDir, {recursive: true});
+
+      for (const testResult of failedTestResults) {
+        for (let i = 0; i < testResult.runs.length; i++) {
+          const run = testResult.runs[i];
+          fs.writeFileSync(`${failuresDir}/${testResult.id}-${i}.json`, JSON.stringify({
+            ...run,
+            lighthouseLog: run.lighthouseLog.split('\n'),
+            assertionLog: run.assertionLog.split('\n'),
+          }, null, 2));
+        }
+      }
+    }
+
+    const cmd = `yarn smoke ${failedTestResults.map(r => r.id).join(' ')}`;
+    console.log(`rerun failures: ${cmd}`);
+  }
+
+  const exitCode = smokehouseResult.success ? 0 : 1;
+  process.exit(exitCode);
+}
+
+await begin();

package/cli/test/smokehouse/lib/child-process-error.d.ts

@@ -0,0 +1,21 @@
+/**
+ * @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.
+ */
+/**
+ * An extension of Error that includes any stdout or stderr from a child
+ * process. Based on the error thrown by `child_process.exec()`.
+ * https://github.com/nodejs/node/blob/3aeae8d81b7b78668c37f7a07a72d94781126d49/lib/child_process.js#L150-L176
+ */
+export class ChildProcessError extends Error {
+    /**
+     * @param {string} message
+     * @param {string=} stdout
+     * @param {string=} stderr
+     */
+    constructor(message: string, stdout?: string | undefined, stderr?: string | undefined);
+    stdout: string;
+    stderr: string;
+}
+//# sourceMappingURL=child-process-error.d.ts.map

package/cli/test/smokehouse/lib/child-process-error.js

@@ -0,0 +1,25 @@
+/**
+ * @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.
+ */
+
+/**
+ * An extension of Error that includes any stdout or stderr from a child
+ * process. Based on the error thrown by `child_process.exec()`.
+ * https://github.com/nodejs/node/blob/3aeae8d81b7b78668c37f7a07a72d94781126d49/lib/child_process.js#L150-L176
+ */
+class ChildProcessError extends Error {
+  /**
+   * @param {string} message
+   * @param {string=} stdout
+   * @param {string=} stderr
+   */
+  constructor(message, stdout = '', stderr = '') {
+    super(message);
+    this.stdout = stdout;
+    this.stderr = stderr;
+  }
+}
+
+export {ChildProcessError};

package/cli/test/smokehouse/lib/concurrent-mapper.d.ts

@@ -0,0 +1,78 @@
+/**
+ * @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.
+ */
+export class ConcurrentMapper {
+    /**
+     * 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 map<T_1, U_2>(values: T_1[], callbackfn: (value: T_1, index: number, array: T_1[]) => Promise<U_2>, options?: {
+        concurrency: number;
+    } | undefined): Promise<U_2[]>;
+    /** @type {Set<Promise<unknown>>} */
+    _promisePool: Set<Promise<unknown>>;
+    /**
+     * The limits of all currently running jobs. There will be duplicates.
+     * @type {Array<number>}
+     */
+    _allConcurrencyLimits: Array<number>;
+    /**
+     * Returns whether there are fewer running jobs than the minimum current
+     * concurrency limit and the proposed new `concurrencyLimit`.
+     * @param {number} concurrencyLimit
+     */
+    _canRunMoreAtLimit(concurrencyLimit: number): boolean;
+    /**
+     * Add a job to pool.
+     * @param {Promise<unknown>} job
+     * @param {number} concurrencyLimit
+     */
+    _addJob(job: Promise<unknown>, concurrencyLimit: number): void;
+    /**
+     * Remove a job from pool.
+     * @param {Promise<unknown>} job
+     * @param {number} concurrencyLimit
+     */
+    _removeJob(job: Promise<unknown>, concurrencyLimit: number): void;
+    /**
+     * 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>>}
+     */
+    pooledMap<T, U>(values: T[], callbackfn: (value: T, index: number, array: T[]) => Promise<U>, options?: {
+        concurrency: number;
+    } | undefined): Promise<U[]>;
+    /**
+     * 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>}
+     */
+    runInPool<U_1>(fn: () => Promise<U_1>, options?: {
+        concurrency: number;
+    } | undefined): Promise<U_1>;
+}
+//# sourceMappingURL=concurrent-mapper.d.ts.map