browsertime 16.16.0 → 17.0.0-beta.0

package/lib/core/seleniumRunner.js

@@ -1,28 +1,23 @@
-'use strict';
-
-const log = require('intel').getLogger('browsertime');
-const merge = require('lodash.merge');
-const get = require('lodash.get');
-const { Condition } = require('selenium-webdriver/lib/webdriver');
-const { isAndroidConfigured } = require('../android');
-const {
-  UrlLoadError,
-  BrowserError,
-  TimeoutError
-} = require('../support/errors');
-const builder = require('./webdriver');
-const getViewPort = require('../support/getViewPort');
-const defaultPageCompleteCheck = require('./pageCompleteChecks/defaultPageCompleteCheck');
-const pageCompleteCheckByInactivity = require('./pageCompleteChecks/pageCompleteCheckByInactivity');
-const spaCheck = require('./pageCompleteChecks/spaInactivity');
+import intel from 'intel';
+import merge from 'lodash.merge';
+import get from 'lodash.get';
+import { Condition } from 'selenium-webdriver';
+import { isAndroidConfigured } from '../android/index.js';
+import { UrlLoadError, BrowserError, TimeoutError } from '../support/errors.js';
+import { createWebDriver } from './webdriver/index.js';
+import getViewPort from '../support/getViewPort.js';
+import defaultPageCompleteCheck from './pageCompleteChecks/defaultPageCompleteCheck.js';
+import pageCompleteCheckByInactivity from './pageCompleteChecks/pageCompleteCheckByInactivity.js';
+import spaCheck from './pageCompleteChecks/spaInactivity.js';
+const log = intel.getLogger('browsertime');
 
 const defaults = {
   timeouts: {
-    browserStart: 60000,
-    pageLoad: 300000,
-    script: 120000,
-    logs: 90000,
-    pageCompleteCheck: 60000
+    browserStart: 60_000,
+    pageLoad: 300_000,
+    script: 120_000,
+    logs: 90_000,
+    pageCompleteCheck: 60_000
   },
   index: 0
 };
@@ -36,7 +31,7 @@ const delay = ms => new Promise(res => setTimeout(res, ms));
  * @param {string} errorMessage - the error message in the Error if we timeouts
  */
 async function timeout(promise, ms, errorMessage) {
-  let timer = null;
+  let timer;
 
   return Promise.race([
     new Promise((resolve, reject) => {
@@ -69,21 +64,21 @@ class SeleniumRunner {
    */
   async start() {
     const tries = this.browserRestartTries;
-    for (let i = 0; i < tries; ++i) {
+    for (let index = 0; index < tries; ++index) {
       try {
         this.driver = await timeout(
-          builder.createWebDriver(this.baseDir, this.options),
+          createWebDriver(this.baseDir, this.options),
           this.options.timeouts.browserStart,
           `Failed to start ${this.options.browser} in ${
             this.options.timeouts.browserStart / 1000
           } seconds.`
         );
         break;
-      } catch (e) {
+      } catch (error) {
         log.info(
           `${this.options.browser} failed to start, trying ${
-            tries - i - 1
-          } more time(s): ${e.message}`
+            tries - index - 1
+          } more time(s): ${error.message}`
         );
       }
     }
@@ -117,7 +112,6 @@ class SeleniumRunner {
           // Android do not support set position nor set size
           if (
             // Hack for Wallmart labs
-            !this.options.android &&
             !isAndroidConfigured(this.options)
           ) {
             await window.setRect({
@@ -129,9 +123,9 @@ class SeleniumRunner {
           }
         }
       }
-    } catch (e) {
-      throw new BrowserError(e.message, {
-        cause: e
+    } catch (error) {
+      throw new BrowserError(error.message, {
+        cause: error
       });
     }
   }
@@ -185,24 +179,24 @@ class SeleniumRunner {
         pageCompleteCheckTimeout,
         `Running page complete check ${pageCompleteCheck} took too long`
       );
-    } catch (e) {
-      if (e instanceof TimeoutError) {
+    } catch (error) {
+      if (error instanceof TimeoutError) {
         log.info(
           `The page did not finished loading in ${pageCompleteCheckTimeout} ms. You can adjust the timeout by setting the --maxLoadTime option (in ms).`
         );
       } else {
         log.error(
           `Failed waiting on page ${
-            url ? url : ''
+            url ?? ''
           } to finished loading, timed out after ${pageCompleteCheckTimeout} ms`,
-          e
+          error
         );
         throw new UrlLoadError(
           `Failed waiting on page ${
-            url ? url : ''
+            url ?? ''
           }  to finished loading, timed out after ${pageCompleteCheckTimeout} ms `,
           {
-            cause: e
+            cause: error
           }
         );
       }
@@ -226,9 +220,9 @@ class SeleniumRunner {
     // See  https://github.com/sitespeedio/browsertime/issues/1698
     const retries = 5;
     let documentURI;
-    for (var i = 0; i < retries; i++) {
+    for (var index = 0; index < retries; index++) {
       documentURI = await driver.executeScript('return document.documentURI;');
-      if (documentURI != null) {
+      if (documentURI != undefined) {
         break;
       }
       await delay(1000);
@@ -236,8 +230,8 @@ class SeleniumRunner {
     let startURI;
     try {
       startURI = new URL(documentURI).toString();
-    } catch (e) {
-      log.error(`Failed to get documentURI ${documentURI}`, e);
+    } catch (error) {
+      log.error(`Failed to get documentURI ${documentURI}`, error);
     }
     if (this.options.webdriverPageload) {
       const clearOrange = `(function() {
@@ -272,18 +266,15 @@ class SeleniumRunner {
     // If you run with default settings, the webdriver will give back
     // control ASAP. Therefore you want to wait some extra time
     // before you start to run your page complete check
-    if (this.options.pageLoadStrategy === 'none') {
-      await delay(this.options.pageCompleteCheckStartWait || 5000);
-    } else {
-      // Give the browser some time to navigate
-      await delay(2000);
-    }
+    this.options.pageLoadStrategy === 'none'
+      ? await delay(this.options.pageCompleteCheckStartWait || 5000)
+      : await delay(2000);
 
     // We give it a couple of times to finish loading, this makes it
     // more stable in real case scenarios on slow servers.
     let totalWaitTime = 0;
     const tries = get(this.options, 'retries', 5) + 1;
-    for (let i = 0; i < tries; ++i) {
+    for (let index = 0; index < tries; ++index) {
       try {
         await this.wait(pageCompleteCheck, normalizedURI);
         const newURI = new URL(
@@ -309,17 +300,17 @@ class SeleniumRunner {
           // We navigated to a new page, we don't need to test anymore
           break;
         } else {
-          const waitTime = (this.options.retryWaitTime || 10000) * (i + 1);
+          const waitTime = (this.options.retryWaitTime || 10_000) * (index + 1);
           totalWaitTime += waitTime;
           log.debug(
             `URL ${url} failed to load, the ${
               this.options.browser
             } are still on ${startURI} , trying ${
-              tries - i - 1
+              tries - index - 1
             } more time(s) but first wait for ${waitTime} ms.`
           );
 
-          if (i === tries - 1) {
+          if (index === tries - 1) {
             // If the last tries through an error, rethrow as before
             const message = `Could not load ${url} - the navigation never happend after ${tries} tries and total wait time of ${totalWaitTime} ms`;
             log.error(message);
@@ -332,18 +323,18 @@ class SeleniumRunner {
             );
           }
         }
-      } catch (e) {
+      } catch (error) {
         log.info(
-          `URL failed to load, trying ${tries - i - 1} more time(s): ${
-            e.message
+          `URL failed to load, trying ${tries - index - 1} more time(s): ${
+            error.message
           }`
         );
         //
-        if (i === tries - 1) {
+        if (index === tries - 1) {
           // If the last tries through an error, rethrow as before
-          log.error('Could not load URL %s', url, e);
+          log.error('Could not load URL %s', url, error);
           throw new UrlLoadError('Failed to load ' + url, url, {
-            cause: e
+            cause: error
           });
         } else {
           await delay(1000);
@@ -371,9 +362,12 @@ class SeleniumRunner {
           `Failed to take screenshot (type was ${typeof base64EncodedPng}`
         );
       }
-    } catch (e) {
-      log.error('Failed to take screenshot' + (url ? ' for ' + url : ''), e);
-      throw new BrowserError('Failed to take screenshot', { cause: e });
+    } catch (error) {
+      log.error(
+        'Failed to take screenshot' + (url ? ' for ' + url : ''),
+        error
+      );
+      throw new BrowserError('Failed to take screenshot', { cause: error });
     }
   }
 
@@ -384,7 +378,7 @@ class SeleniumRunner {
    * @param {*} args - arguments to the script
    * @throws {BrowserError}
    */
-  async runScript(script, name, args) {
+  async runScript(script, name, arguments_) {
     let scriptTimeout = this.options.timeouts.script;
 
     if (log.isEnabledFor(log.TRACE)) {
@@ -395,14 +389,14 @@ class SeleniumRunner {
 
     try {
       const result = await timeout(
-        this.driver.executeScript(script, args),
+        this.driver.executeScript(script, arguments_),
         scriptTimeout,
         `Running script ${script} took too long (${scriptTimeout} ms).`
       );
       return result;
-    } catch (e) {
-      log.error("Couldn't execute script named " + name + ' error:' + e);
-      throw e;
+    } catch (error) {
+      log.error("Couldn't execute script named " + name + ' error:' + error);
+      throw error;
     }
   }
 
@@ -413,7 +407,7 @@ class SeleniumRunner {
    * @param {*} args - arguments to the script
    * @throws {BrowserError}
    */
-  async runPrivilegedScript(script, name, args) {
+  async runPrivilegedScript(script, name, arguments_) {
     if (this.options.browser !== 'firefox') {
       throw new BrowserError(
         `Only Firefox browsers can run privileged JavaScript: ${this.options.browser}`,
@@ -428,15 +422,15 @@ class SeleniumRunner {
 
     try {
       await this.driver.setContext('chrome');
-      const result = await this.driver.executeScript(script, args);
+      const result = await this.driver.executeScript(script, arguments_);
       await this.driver.setContext(oldContext);
       return result;
-    } catch (e) {
+    } catch (error) {
       log.error(
-        "Couldn't execute privileged script named " + name + ' error:' + e
+        "Couldn't execute privileged script named " + name + ' error:' + error
       );
       await this.driver.setContext(oldContext);
-      throw e;
+      throw error;
     }
   }
 
@@ -447,13 +441,13 @@ class SeleniumRunner {
    * @param {*} args - arguments to the script
    * @throws {BrowserError}
    */
-  async runAsyncScript(script, name, args) {
+  async runAsyncScript(script, name, arguments_) {
     if (log.isEnabledFor(log.TRACE)) {
       log.verbose('Executing async script %s', script);
     } else if (log.isEnabledFor(log.VERBOSE)) {
       log.verbose('Executing async script %s', name);
     }
-    return this.driver.executeAsyncScript(script, args);
+    return this.driver.executeAsyncScript(script, arguments_);
   }
 
   /**
@@ -463,7 +457,7 @@ class SeleniumRunner {
    * @param {*} args - arguments to the script
    * @throws {BrowserError}
    */
-  async runPrivilegedAsyncScript(script, name, args) {
+  async runPrivilegedAsyncScript(script, name, arguments_) {
     if (this.options.browser !== 'firefox') {
       throw new BrowserError(
         `Only Firefox browsers can run privileged JavaScript: ${this.options.browser}`,
@@ -477,12 +471,14 @@ class SeleniumRunner {
     try {
       const oldContext = await this.driver.getContext();
       await this.driver.setContext('chrome');
-      const result = await this.driver.executeAsyncScript(script, args);
+      const result = await this.driver.executeAsyncScript(script, arguments_);
       await this.driver.setContext(oldContext);
       return result;
-    } catch (ce) {
-      log.error("Couldn't execute async script named " + name + ' error:' + ce);
-      throw ce;
+    } catch (error) {
+      log.error(
+        "Couldn't execute async script named " + name + ' error:' + error
+      );
+      throw error;
     }
   }
 
@@ -510,12 +506,12 @@ class SeleniumRunner {
       try {
         return timeout(
           this.driver.quit(),
-          120000,
+          120_000,
           'Could not close the browser using driver.quit'
         );
-      } catch (e) {
-        throw new BrowserError(e.message, {
-          cause: e
+      } catch (error) {
+        throw new BrowserError(error.message, {
+          cause: error
         });
       }
     }
@@ -535,11 +531,9 @@ class SeleniumRunner {
     let scriptRunner = this.runScript.bind(this);
 
     if (isAsync) {
-      if (privilegeWanted) {
-        scriptRunner = this.runPrivilegedAsyncScript.bind(this);
-      } else {
-        scriptRunner = this.runAsyncScript.bind(this);
-      }
+      scriptRunner = privilegeWanted
+        ? this.runPrivilegedAsyncScript.bind(this)
+        : this.runAsyncScript.bind(this);
     } else {
       if (privilegeWanted) {
         scriptRunner = this.runPrivilegedScript.bind(this);
@@ -568,11 +562,9 @@ class SeleniumRunner {
       }
     } else {
       const source = 'return ' + script;
-      if (this.options.scriptInput && this.options.scriptInput[name]) {
-        return scriptRunner(source, name, this.options.scriptInput[name]);
-      } else {
-        return scriptRunner(source, name);
-      }
+      return this.options.scriptInput && this.options.scriptInput[name]
+        ? scriptRunner(source, name, this.options.scriptInput[name])
+        : scriptRunner(source, name);
     }
   }
 
@@ -598,17 +590,17 @@ class SeleniumRunner {
           category,
           isAsync
         );
-      } catch (e) {
-        if (e.extra && e.extra.cause === 'PrivilegeError') {
+      } catch (error) {
+        if (error.extra && error.extra.cause === 'PrivilegeError') {
           // Ignore those scripts that fail to execute because they
           // wanted privileges that the browser cannot provide.
           log.verbose(
             'Did not have enough privileges to execute user script: ' +
-              e +
+              error +
               '; ignoring.'
           );
         } else {
-          log.error('Failed to execute user script: ' + e);
+          log.error('Failed to execute user script: ' + error);
           results[categoryName] = undefined;
         }
       }
@@ -639,8 +631,8 @@ class SeleniumRunner {
       // the function is not null and we want to run
       // the function.
       if (!script) {
-        let func = category[scriptName].function;
-        if (!func) {
+        let function_ = category[scriptName].function;
+        if (!function_) {
           throw (
             'Function and script cannot both be null in ' + scriptName + '.'
           );
@@ -651,7 +643,7 @@ class SeleniumRunner {
         // invocation. The script writer cannot do this in their
         // source because it would force the evaluation of the
         // function too soon and cause undefined reference errors.
-        script = '( ' + func + ' )()';
+        script = '( ' + function_ + ' )()';
         requires = category[scriptName].requires;
         isAsyncOverride = category[scriptName].isAsync;
       }
@@ -676,4 +668,4 @@ class SeleniumRunner {
   }
 }
 
-module.exports = SeleniumRunner;
+export default SeleniumRunner;

package/lib/core/webdriver/index.js

@@ -1,11 +1,9 @@
-'use strict';
-
-const webdriver = require('selenium-webdriver');
-const isEmpty = require('lodash.isempty');
-const chrome = require('../../chrome/webdriver/builder');
-const edge = require('../../edge/webdriver/builder');
-const firefox = require('../../firefox/webdriver/builder');
-const safari = require('../../safari/webdriver/builder');
+import { Builder } from 'selenium-webdriver';
+import isEmpty from 'lodash.isempty';
+import { configureBuilder as configureBuilderChrome } from '../../chrome/webdriver/builder.js';
+import { configureBuilder as configureBuilderEdge } from '../../edge/webdriver/builder.js';
+import { configureBuilder as configureBuilderFirefox } from '../../firefox/webdriver/builder.js';
+import { configureBuilder as configureBuilderSafari } from '../../safari/webdriver/builder.js';
 
 /**
  * Create a new WebDriver instance based on the specified options.
@@ -13,14 +11,14 @@ const safari = require('../../safari/webdriver/builder');
  * @returns {!Promise<webdriver.WebDriver>} a promise that resolves to the webdriver,
  * or rejects if the current configuration is invalid.
  */
-module.exports.createWebDriver = async function (baseDir, options) {
+export async function createWebDriver(baseDir, options) {
   const browser = options.browser || 'chrome';
   const seleniumUrl = options.selenium ? options.selenium.url : undefined;
   const capabilities = options.selenium
     ? options.selenium.capabilities
     : undefined;
 
-  const builder = new webdriver.Builder()
+  const builder = new Builder()
     .forBrowser(browser === 'edge' ? 'MicrosoftEdge' : browser)
     .usingServer(seleniumUrl);
 
@@ -32,25 +30,30 @@ module.exports.createWebDriver = async function (baseDir, options) {
   }
 
   switch (browser) {
-    case 'chrome':
-      chrome.configureBuilder(builder, baseDir, options);
+    case 'chrome': {
+      await configureBuilderChrome(builder, baseDir, options);
       break;
+    }
 
-    case 'firefox':
-      firefox.configureBuilder(builder, baseDir, options);
+    case 'firefox': {
+      await configureBuilderFirefox(builder, baseDir, options);
       break;
+    }
 
-    case 'safari':
-      await safari.configureBuilder(builder, baseDir, options);
+    case 'safari': {
+      await configureBuilderSafari(builder, baseDir, options);
       break;
+    }
 
-    case 'edge':
-      edge.configureBuilder(builder, baseDir, options);
+    case 'edge': {
+      await configureBuilderEdge(builder, baseDir, options);
       break;
+    }
 
-    default:
-      return Promise.reject(new Error('Unsupported browser: ' + browser));
+    default: {
+      throw new Error('Unsupported browser: ' + browser);
+    }
   }
 
   return builder.build();
-};
+}

package/lib/edge/webdriver/builder.js

@@ -1,13 +1,14 @@
-const edge = require('selenium-webdriver/edge');
-const log = require('intel').getLogger('browsertime.edge');
-const get = require('lodash.get');
-const proxy = require('selenium-webdriver/proxy');
-const pick = require('lodash.pick');
-const isEmpty = require('lodash.isempty');
-const webdriver = require('selenium-webdriver');
-const setupChromiumOptions = require('../../chrome/webdriver/setupChromiumOptions');
-
-module.exports.configureBuilder = function (builder, baseDir, options) {
+import { Options, ServiceBuilder } from 'selenium-webdriver/edge.js';
+import intel from 'intel';
+import get from 'lodash.get';
+import pick from 'lodash.pick';
+import isEmpty from 'lodash.isempty';
+import { logging } from 'selenium-webdriver';
+import setupChromiumOptions from '../../chrome/webdriver/setupChromiumOptions.js';
+const log = intel.getLogger('browsertime.edge');
+const { pac, manual } = 'selenium-webdriver/proxy.js';
+
+export async function configureBuilder(builder, baseDir, options) {
   const edgeConfig = options.edge || {};
   const chromeConfig = options.chrome || {};
 
@@ -15,16 +16,16 @@ module.exports.configureBuilder = function (builder, baseDir, options) {
   const edgePath = get(edgeConfig, 'binaryPath');
 
   if (!edgedriverPath) {
-    const edgedriver = require('@sitespeed.io/edgedriver');
-    edgedriverPath = edgedriver.binPath();
+    const edgedriver = await import('@sitespeed.io/edgedriver');
+    edgedriverPath = edgedriver.default.binPath();
   }
 
-  let edgeOptions = new edge.Options();
+  let edgeOptions = new Options();
   if (edgePath) {
     edgeOptions.setBinaryPath(edgePath);
   }
 
-  const serviceBuilder = new edge.ServiceBuilder(edgedriverPath);
+  const serviceBuilder = new ServiceBuilder(edgedriverPath);
 
   // Remove the check that matches the Edgedriver version with Edge version.
   serviceBuilder.addArguments('--disable-build-check');
@@ -47,26 +48,20 @@ module.exports.configureBuilder = function (builder, baseDir, options) {
   const proxyPacSettings = pick(options.proxy, ['pac']);
 
   if (!isEmpty(proxyPacSettings)) {
-    builder.setProxy(proxy.pac(proxyPacSettings));
+    builder.setProxy(pac(proxyPacSettings));
   }
 
   const proxySettings = pick(options.proxy, ['ftp', 'http', 'https', 'bypass']);
 
   if (!isEmpty(proxySettings)) {
-    builder.setProxy(proxy.manual(proxySettings));
+    builder.setProxy(manual(proxySettings));
   }
 
-  let logPrefs = new webdriver.logging.Preferences();
-  logPrefs.setLevel(
-    webdriver.logging.Type.PERFORMANCE,
-    webdriver.logging.Level.ALL
-  );
+  let logPrefs = new logging.Preferences();
+  logPrefs.setLevel(logging.Type.PERFORMANCE, logging.Level.ALL);
 
   if (chromeConfig.collectConsoleLog) {
-    logPrefs.setLevel(
-      webdriver.logging.Type.BROWSER,
-      webdriver.logging.Level.ALL
-    );
+    logPrefs.setLevel(logging.Type.BROWSER, logging.Level.ALL);
   }
 
   // edgeOptions.setLoggingPrefs(logPrefs);
@@ -79,4 +74,4 @@ module.exports.configureBuilder = function (builder, baseDir, options) {
   setupChromiumOptions(edgeOptions, chromeConfig, options, baseDir);
 
   builder.setEdgeOptions(edgeOptions);
-};
+}

package/lib/extensionserver/httpServer.js

@@ -1,24 +1,20 @@
-'use strict';
+import { promisify } from 'node:util';
+import { createServer } from 'node:http';
 
-const { promisify } = require('util');
-const http = require('http');
-
-module.exports = {
-  async startServer() {
-    const server = http.createServer((req, res) => {
-      res.writeHead(200, {
-        'Content-Type': 'text/html',
-        'Referrer-Policy': 'no-referrer'
-      });
-      res.end('<html><body></body></html>');
+export async function startServer() {
+  const server = createServer((request, res) => {
+    res.writeHead(200, {
+      'Content-Type': 'text/html',
+      'Referrer-Policy': 'no-referrer'
     });
+    res.end('<html><body></body></html>');
+  });
 
-    const listen = promisify(server.listen.bind(server));
-    await listen();
-    return server;
-  },
-  async stopServer(server) {
-    const close = promisify(server.close.bind(server));
-    return close();
-  }
-};
+  const listen = promisify(server.listen.bind(server));
+  await listen();
+  return server;
+}
+export async function stopServer(server) {
+  const close = promisify(server.close.bind(server));
+  return close();
+}