browsertime 16.16.0 → 17.0.0-beta.0

package/lib/support/cli.js

@@ -1,23 +1,34 @@
-'use strict';
+import { format } from 'node:util';
+import { readFileSync, statSync } from 'node:fs';
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import { findUpSync } from 'find-up';
+import get from 'lodash.get';
+import set from 'lodash.set';
+import hasbin from 'hasbin';
+import {
+  framerate,
+  crf,
+  addTimer,
+  threads,
+  xvfbDisplay
+} from '../video/defaults.js';
+import SCREENSHOT from '../screenshot/defaults.js';
+import {
+  features,
+  threads as _threads,
+  desktop_sampling_interval,
+  android_sampling_interval,
+  bufferSize
+} from '../firefox/settings/geckoProfilerDefaults.js';
 
-const yargs = require('yargs');
-const fs = require('fs');
-const findUp = require('find-up');
-const get = require('lodash.get');
-const set = require('lodash.set');
-const util = require('util');
-const hasbin = require('hasbin');
-const videoDefaults = require('../video/defaults');
-const screenshotDefaults = require('../screenshot/defaults');
-const geckoProfilerDefaults = require('../firefox/settings/geckoProfilerDefaults');
+const configPath = findUpSync(['.browsertime.json']);
 
-const configPath = findUp.sync(['.browsertime.json']);
 let config;
-
 try {
-  config = configPath ? JSON.parse(fs.readFileSync(configPath)) : {};
-} catch (e) {
-  if (e instanceof SyntaxError) {
+  config = configPath ? JSON.parse(readFileSync(configPath)) : {};
+} catch (error) {
+  if (error instanceof SyntaxError) {
     /* eslint no-console: off */
     console.error(
       'Could not parse the config JSON file ' +
@@ -25,13 +36,13 @@ try {
         '. Is the file really valid JSON?'
     );
   }
-  throw e;
+  throw error;
 }
 
 function validateInput(argv) {
   // Check NodeJS major version
   const fullVersion = process.versions.node;
-  const minVersion = 10;
+  const minVersion = 14;
   const majorVersion = fullVersion.split('.')[0];
   if (majorVersion < minVersion) {
     return (
@@ -48,9 +59,9 @@ function validateInput(argv) {
     if (!urlOrFile.startsWith('http')) {
       // is existing file?
       try {
-        fs.statSync(urlOrFile);
-      } catch (e) {
-        return util.format(
+        statSync(urlOrFile);
+      } catch {
+        return format(
           "'%s' does not exist, is the path to the file correct?",
           urlOrFile
         );
@@ -65,10 +76,8 @@ function validateInput(argv) {
     }
   }
 
-  if (argv.video || argv.visualMetrics) {
-    if (!hasbin.all.sync(['ffmpeg'])) {
-      return 'You need to have ffmpeg in your path to be able to record a video.';
-    }
+  if ((argv.video || argv.visualMetrics) && !hasbin.sync(['ffmpeg'])) {
+    return 'You need to have ffmpeg in your path to be able to record a video.';
   }
 
   if (argv.safari && argv.safari.useSimulator && !argv.safari.deviceUDID) {
@@ -87,22 +96,20 @@ function validateInput(argv) {
     return 'There is no benefit running debug mode inside a Docker container.';
   }
 
-  if (argv.tcpdump) {
-    if (!hasbin.all.sync(['tcpdump'])) {
-      return 'You need to have tcpdump in your path to be able to record a tcpdump.';
-    }
+  if (argv.tcpdump && !hasbin.sync(['tcpdump'])) {
+    return 'You need to have tcpdump in your path to be able to record a tcpdump.';
   }
 
-  if (argv.gnirehtet) {
-    if (!hasbin.all.sync(['gnirehtet'])) {
-      return 'You need to have gnirehtet in your path to be able to use it. If you run on a Mac you can install it using Homebrew: brew install gnirehtet';
-    }
+  if (argv.gnirehtet && !hasbin.sync(['gnirehtet'])) {
+    return 'You need to have gnirehtet in your path to be able to use it. If you run on a Mac you can install it using Homebrew: brew install gnirehtet';
   }
 
-  if (argv.connectivity && argv.connectivity.engine === 'humble') {
-    if (!argv.connectivity.humble || !argv.connectivity.humble.url) {
-      return 'You need to specify the URL to Humble by using the --connectivity.humble.url option.';
-    }
+  if (
+    argv.connectivity &&
+    argv.connectivity.engine === 'humble' &&
+    (!argv.connectivity.humble || !argv.connectivity.humble.url)
+  ) {
+    return 'You need to specify the URL to Humble by using the --connectivity.humble.url option.';
   }
 
   if (
@@ -137,33 +144,34 @@ function validateInput(argv) {
   return true;
 }
 
-module.exports.parseCommandLine = function parseCommandLine() {
-  let validated = yargs
+export function parseCommandLine() {
+  let yargsInstance = yargs(hideBin(process.argv));
+  let validated = yargsInstance
     .parserConfiguration({ 'deep-merge-config': true })
     .env('BROWSERTIME')
     .usage('$0 [options] <url>/<scriptFile>')
     .require(1, 'One or more url or script files')
     .option('timeouts.browserStart', {
-      default: 60000,
+      default: 60_000,
       type: 'number',
       describe: 'Timeout when waiting for browser to start, in milliseconds',
       group: 'timeouts'
     })
     .option('timeouts.pageLoad', {
-      default: 300000,
+      default: 300_000,
       type: 'number',
       describe: 'Timeout when waiting for url to load, in milliseconds',
       group: 'timeouts'
     })
     .option('timeouts.script', {
-      default: 120000,
+      default: 120_000,
       type: 'number',
       describe: 'Timeout when running browser scripts, in milliseconds',
       group: 'timeouts'
     })
     .option('timeouts.pageCompleteCheck', {
       alias: 'maxLoadTime',
-      default: 120000,
+      default: 120_000,
       type: 'number',
       describe:
         'Timeout when waiting for page to complete loading, in milliseconds',
@@ -311,11 +319,13 @@ module.exports.parseCommandLine = function parseCommandLine() {
       describe:
         'Easy way to enable both chrome.timeline for Chrome and geckoProfile for Firefox'
     })
-    .option('androidPower', {
+    .option('android.powerTesting', {
+      alias: 'androidPower',
       type: 'boolean',
       describe:
         'Enables android power testing - charging must be disabled for this.' +
-        '(You have to disable charging yourself for this - it depends on the phone model).'
+        '(You have to disable charging yourself for this - it depends on the phone model).',
+      group: 'android'
     })
     .option('chrome.CPUThrottlingRate', {
       type: 'number',
@@ -458,24 +468,24 @@ module.exports.parseCommandLine = function parseCommandLine() {
     })
     .option('firefox.geckoProfilerParams.features', {
       describe: 'Enabled features during gecko profiling',
-      default: geckoProfilerDefaults.features,
+      default: features,
       type: 'string',
       group: 'firefox'
     })
     .option('firefox.geckoProfilerParams.threads', {
       describe: 'Threads to profile.',
-      default: geckoProfilerDefaults.threads,
+      default: _threads,
       type: 'string',
       group: 'firefox'
     })
     .option('firefox.geckoProfilerParams.interval', {
-      describe: `Sampling interval in ms.  Defaults to ${geckoProfilerDefaults.desktop_sampling_interval} on desktop, and ${geckoProfilerDefaults.android_sampling_interval} on android.`,
+      describe: `Sampling interval in ms.  Defaults to ${desktop_sampling_interval} on desktop, and ${android_sampling_interval} on android.`,
       type: 'number',
       group: 'firefox'
     })
     .option('firefox.geckoProfilerParams.bufferSize', {
       describe: 'Buffer size in elements. Default is ~90MB.',
-      default: geckoProfilerDefaults.bufferSize,
+      default: bufferSize,
       type: 'number',
       group: 'firefox'
     })
@@ -488,7 +498,8 @@ module.exports.parseCommandLine = function parseCommandLine() {
     })
     .option('firefox.perfStatsParams.mask', {
       describe: 'Mask to decide which features to enable',
-      default: 0xffffffff,
+      // eslint-disable-next-line prettier/prettier
+      default: 0xFF_FF_FF_FF,
       type: 'number',
       group: 'firefox'
     })
@@ -567,19 +578,19 @@ module.exports.parseCommandLine = function parseCommandLine() {
         'Record a video and store the video. Set it to false to remove the video that is created by turning on visualMetrics. To remove fully turn off video recordings, make sure to set video and visualMetrics to false. Requires FFMpeg to be installed.'
     })
     .option('videoParams.framerate', {
-      default: videoDefaults.framerate,
+      default: framerate,
       describe: 'Frames per second',
       group: 'video'
     })
     .option('videoParams.crf', {
-      default: videoDefaults.crf,
+      default: crf,
       describe:
         'Constant rate factor see https://trac.ffmpeg.org/wiki/Encode/H.264#crf',
       group: 'video'
     })
     .option('videoParams.addTimer', {
       type: 'boolean',
-      default: videoDefaults.addTimer,
+      default: addTimer,
       describe: 'Add timer and metrics to the video.',
       group: 'video'
     })
@@ -635,7 +646,7 @@ module.exports.parseCommandLine = function parseCommandLine() {
       group: 'video'
     })
     .option('videoParams.threads', {
-      default: videoDefaults.threads,
+      default: threads,
       describe:
         'Number of threads to use for video recording. Default is determined by ffmpeg.',
       group: 'video'
@@ -661,6 +672,7 @@ module.exports.parseCommandLine = function parseCommandLine() {
     })
     .option('visualMetricsPortable', {
       type: 'boolean',
+      default: true,
       describe:
         'Use the portable visual-metrics processing script (no ImageMagick dependencies).'
     })
@@ -682,50 +694,71 @@ module.exports.parseCommandLine = function parseCommandLine() {
       describe:
         'Specify browser. Safari only works on OS X/iOS. Edge only work on OS that supports Edge.'
     })
+    .option('android.ignoreShutdownFailures', {
+      alias: 'ignoreShutdownFailures',
+      type: 'boolean',
+      default: false,
+      describe: 'If set, shutdown failures will be ignored on Android.',
+      group: 'android'
+    })
     .option('android', {
       type: 'boolean',
       default: false,
       describe:
         'Short key to use Android. Defaults to use com.android.chrome unless --browser is specified.'
     })
-    .option('androidRooted', {
+    .option('android.rooted', {
       type: 'boolean',
+      alias: 'androidRooted',
       default: false,
       describe:
-        'If your phone is rooted you can use this to set it up following Mozillas best practice for stable metrics.'
+        'If your phone is rooted you can use this to set it up following Mozillas best practice for stable metrics.',
+      group: 'android'
     })
-    .option('androidBatteryTemperatureLimit', {
+    .option('android.batteryTemperatureLimit', {
+      alias: 'androidBatteryTemperatureLimit',
       type: 'integer',
       describe:
-        'Do the battery temperature need to be below a specific limit before we start the test?'
+        'Do the battery temperature need to be below a specific limit before we start the test?',
+      group: 'android'
     })
-    .option('androidBatteryTemperatureWaitTimeInSeconds', {
+    .option('android.batteryTemperatureWaitTimeInSeconds', {
+      alias: 'androidBatteryTemperatureWaitTimeInSeconds',
       type: 'integer',
       default: 120,
       describe:
-        'How long time to wait (in seconds) if the androidBatteryTemperatureWaitTimeInSeconds is not met before the next try'
+        'How long time to wait (in seconds) if the androidBatteryTemperatureWaitTimeInSeconds is not met before the next try',
+      group: 'android'
     })
-    .option('androidBatteryTemperatureReboot', {
+    .option('android.batteryTemperatureReboot', {
+      alias: 'androidBatteryTemperatureReboot',
       type: 'boolean',
       default: false,
       describe:
-        'If your phone does not get the minimum temperature aftet the wait time, reboot the phone.'
+        'If your phone does not get the minimum temperature aftet the wait time, reboot the phone.',
+      group: 'android'
     })
-    .option('androidPretestPowerPress', {
+    .option('android.pretestPowerPress', {
+      alias: 'androidPretestPowerPress',
       type: 'boolean',
       default: false,
-      describe: 'Press the power button on the phone before a test starts.'
+      describe: 'Press the power button on the phone before a test starts.',
+      group: 'android'
     })
-    .option('androidPretestPressHomeButton', {
+    .option('android.pretestPressHomeButton', {
+      alias: 'androidPretestPressHomeButton',
       type: 'boolean',
       default: false,
-      describe: 'Press the home button on the phone before a test starts.'
+      describe: 'Press the home button on the phone before a test starts.',
+      group: 'android'
     })
-    .option('androidVerifyNetwork', {
+    .option('android.verifyNetwork', {
+      alias: 'androidVerifyNetwork',
       type: 'boolean',
       default: false,
       describe:
-        'Before a test start, verify that the device has a Internet connection by pinging 8.8.8.8 (or a configurable domain with --androidPingAddress)'
+        'Before a test start, verify that the device has a Internet connection by pinging 8.8.8.8 (or a configurable domain with --androidPingAddress)',
+      group: 'android'
     })
     /** Process start time.  Android-only for now. */
     .option('processStartTime', {
@@ -807,22 +840,22 @@ module.exports.parseCommandLine = function parseCommandLine() {
     .option('screenshotParams.type', {
       describe: 'Set the file type of the screenshot',
       choices: ['png', 'jpg'],
-      default: screenshotDefaults.type,
+      default: SCREENSHOT.type,
       group: 'Screenshot'
     })
     .option('screenshotParams.png.compressionLevel', {
       describe: 'zlib compression level',
-      default: screenshotDefaults.png.compressionLevel,
+      default: SCREENSHOT.png.compressionLevel,
       group: 'Screenshot'
     })
     .option('screenshotParams.jpg.quality', {
       describe: 'Quality of the JPEG screenshot. 1-100',
-      default: screenshotDefaults.jpg.quality,
+      default: SCREENSHOT.jpg.quality,
       group: 'Screenshot'
     })
     .option('screenshotParams.maxSize', {
       describe: 'The max size of the screenshot (width and height).',
-      default: screenshotDefaults.maxSize,
+      default: SCREENSHOT.maxSize,
       group: 'Screenshot'
     })
     .option('pageCompleteCheck', {
@@ -1096,7 +1129,7 @@ module.exports.parseCommandLine = function parseCommandLine() {
       describe: 'Start xvfb before the browser is started'
     })
     .option('xvfbParams.display', {
-      default: videoDefaults.xvfbDisplay,
+      default: xvfbDisplay,
       describe: 'The display used for xvfb'
     })
     .option('tcpdump', {
@@ -1137,11 +1170,13 @@ module.exports.parseCommandLine = function parseCommandLine() {
       describe:
         'Run the browser in headless mode. Works for Firefox and Chrome.'
     })
-    .option('gnirehtet', {
+    .option('android.gnirehtet', {
+      alias: 'gnirehtet',
       type: 'boolean',
       default: false,
       describe:
-        'Start gnirehtet and reverse tethering the traffic from your Android phone.'
+        'Start gnirehtet and reverse tethering the traffic from your Android phone.',
+      group: 'android'
     })
     .option('flushDNS', {
       type: 'boolean',
@@ -1191,18 +1226,21 @@ module.exports.parseCommandLine = function parseCommandLine() {
     .alias('h', 'help')
     .alias('V', 'version')
     .alias('v', 'verbose')
+    .wrap(yargsInstance.terminalWidth())
     .check(validateInput);
 
-  validated.wrap(yargs.terminalWidth());
-
   let argv = validated.argv;
 
+  // hack to keep backward compability to --android
+  if (argv.android[0] === true) {
+    set(argv, 'android.enabled', true);
+  }
   if (
     argv.firefox &&
     (argv.firefox.nightly || argv.firefox.beta || argv.firefox.developer)
   ) {
     argv.browser = 'firefox';
-    if (argv.android) {
+    if (argv.android.enabled) {
       // TODO add support for Firefox dev
       set(
         argv,
@@ -1220,7 +1258,7 @@ module.exports.parseCommandLine = function parseCommandLine() {
 
   if (argv.ios) {
     set(argv, 'safari.ios', true);
-  } else if (argv.android) {
+  } else if (argv.android.enabled) {
     if (argv.browser === 'chrome') {
       // Default to Chrome Android.
       set(
@@ -1257,8 +1295,8 @@ module.exports.parseCommandLine = function parseCommandLine() {
 
     if (!Array.isArray(argv.urlAlias)) argv.urlAlias = [argv.urlAlias];
 
-    for (let i = 0; i < urls.length; i++) {
-      urlMetaData[urls[i]] = argv.urlAlias[i];
+    for (const [index, url] of urls.entries()) {
+      urlMetaData[url] = argv.urlAlias[index];
     }
     set(argv, 'urlMetaData', urlMetaData);
   }
@@ -1279,13 +1317,13 @@ module.exports.parseCommandLine = function parseCommandLine() {
 
   // Set the timeouts to a maximum while debugging
   if (argv.debug) {
-    set(argv, 'timeouts.pageload', 2147483647);
-    set(argv, 'timeouts.script', 2147483647);
-    set(argv, 'timeouts.pageCompleteCheck', 2147483647);
+    set(argv, 'timeouts.pageload', 2_147_483_647);
+    set(argv, 'timeouts.script', 2_147_483_647);
+    set(argv, 'timeouts.pageCompleteCheck', 2_147_483_647);
   }
 
   return {
     urls: argv._,
     options: argv
   };
-};
+}

package/lib/support/dns.js

@@ -1,10 +1,9 @@
-'use strict';
+import { execa } from 'execa';
+import intel from 'intel';
+import { isAndroidConfigured } from '../android/index.js';
+const log = intel.getLogger('browsertime.dns');
 
-const execa = require('execa');
-const log = require('intel').getLogger('browsertime.dns');
-const { isAndroidConfigured } = require('../android');
-
-module.exports = async function (options) {
+export default async function (options) {
   if (isAndroidConfigured(options)) {
     return;
   }
@@ -36,4 +35,4 @@ module.exports = async function (options) {
       reject: false
     });
   }
-};
+}

package/lib/support/engineUtils.js

@@ -1,46 +1,93 @@
-'use strict';
+import { resolve } from 'node:path';
+import { createRequire } from 'node:module';
+import dayjs from 'dayjs';
+import intel from 'intel';
+import { toArray } from '../support/util.js';
+import {
+  removeFile,
+  copyFile,
+  removeFileSync,
+  copyFileSync
+} from './fileUtil.js';
+const require = createRequire(import.meta.url);
+const log = intel.getLogger('browsertime');
 
-const path = require('path');
-const dayjs = require('dayjs');
-const util = require('../support/util');
-const log = require('intel').getLogger('browsertime');
 const AsyncFunction = Object.getPrototypeOf(async function () {}).constructor;
 
-module.exports = {
-  loadPrePostScripts(scripts) {
-    return util.toArray(scripts).map(script => {
-      // if the script is an AsyncFunction, return it.
-      if (script instanceof AsyncFunction) {
-        return script;
-      }
-      try {
-        return require(path.resolve(script));
-      } catch (e) {
-        throw new Error(
-          "Couldn't run pre/post script file: " + path.resolve(script) + ' ' + e
-        );
+export function loadPrePostScriptsSync(scripts) {
+  return toArray(scripts).map(script => {
+    // if the script is an AsyncFunction, return it.
+    if (script instanceof AsyncFunction) {
+      return script;
+    }
+    try {
+      if (script.endsWith('.js')) {
+        const name = script + '.cjs';
+        copyFileSync(script, name);
+        const data = require(resolve(name));
+        removeFileSync(name);
+        return data;
+      } else {
+        return require(resolve(script));
       }
-    });
-  },
-  loadScript(script, throwError) {
-    if (script) {
-      // if the script is an AsyncFunction, return it.
-      if (script instanceof AsyncFunction) {
-        return script;
+    } catch (error) {
+      throw new Error(
+        "Couldn't run pre/post script file: " + resolve(script) + ' ' + error
+      );
+    }
+  });
+}
+
+export function loadScriptSync(script) {
+  if (script instanceof AsyncFunction) {
+    return script;
+  }
+  try {
+    if (script.endsWith('.js')) {
+      const name = script + '.cjs';
+      copyFileSync(script, name);
+      const data = require(resolve(name));
+      removeFileSync(name);
+      return data;
+    } else {
+      return require(resolve(script));
+    }
+  } catch {
+    // assume the script is a valid inline script by default
+    return script;
+  }
+}
+
+export async function loadScript(script, throwError) {
+  if (script) {
+    // if the script is an AsyncFunction, return it.
+    if (script instanceof AsyncFunction) {
+      return script;
+    }
+    try {
+      if (script.endsWith('.js')) {
+        const name = script + '.cjs';
+        await copyFile(script, name);
+        const data = require(resolve(name));
+        await removeFile(name);
+        return data;
+      } else {
+        return require(resolve(script));
       }
-      try {
-        return require(path.resolve(script));
-      } catch (e) {
-        // assume the script is a valid inline script by default
-        if (throwError) {
-          log.error('Could not parse user script %s with error %s', script, e);
-          throw e;
-        }
+    } catch (error) {
+      // assume the script is a valid inline script by default
+      if (throwError) {
+        log.error(
+          'Could not parse user script %s with error %s',
+          script,
+          error
+        );
+        throw error;
       }
     }
-    return script;
-  },
-  timestamp() {
-    return dayjs().format();
   }
-};
+  return script;
+}
+export function timestamp() {
+  return dayjs().format();
+}

package/lib/support/errors.js

@@ -1,6 +1,4 @@
-'use strict';
-
-class BrowsertimeError extends Error {
+export class BrowsertimeError extends Error {
   constructor(message, extra) {
     super(message);
     this.extra = extra || {};
@@ -8,29 +6,22 @@ class BrowsertimeError extends Error {
   }
 }
 
-class BrowserError extends BrowsertimeError {
+export class BrowserError extends BrowsertimeError {
   constructor(message, extra) {
     super(message, extra);
   }
 }
 
-class UrlLoadError extends BrowsertimeError {
+export class UrlLoadError extends BrowsertimeError {
   constructor(message, url, extra) {
     super(message, extra);
     this.url = url;
   }
 }
 
-class TimeoutError extends BrowsertimeError {
+export class TimeoutError extends BrowsertimeError {
   constructor(message, url, extra) {
     super(message, extra);
     this.url = url;
   }
 }
-
-module.exports = {
-  BrowsertimeError,
-  BrowserError,
-  UrlLoadError,
-  TimeoutError
-};