pagean 6.0.8 → 6.0.9

package/README.md

@@ -1,6 +1,6 @@
 # Pagean
 
-Pagean is a web page analysis tool designed to automate tests requiring web pages to be loaded in a browser window (e.g. 404 error loading an external resource, page renders with horizontal scrollbars).  The specific tests are outlined below, but are all general tests that do not include any page-specific logic.
+Pagean is a web page analysis tool designed to automate tests requiring web pages to be loaded in a browser window (e.g. 404 error loading an external resource, page renders with horizontal scrollbars). The specific tests are outlined below, but are all general tests that do not include any page-specific logic.
 
 ## Installation
 
@@ -27,57 +27,57 @@ Options:
   -h, --help           display help for command
 ```
 
-Pagean requires a configuration file named, which can be specified via the CLI as detailed above, or use the default file `.pageanrc.json` in the project root.  This file provides the URLs to be tested and options to configure the tests and reports.  Details on the available tests and the configuration file format are provided below.
+Pagean requires a configuration file named, which can be specified via the CLI as detailed above, or use the default file `.pageanrc.json` in the project root. This file provides the URLs to be tested and options to configure the tests and reports. Details on the available tests and the configuration file format are provided below.
 
 ## Test Cases
 
-The tests use [Puppeteer](https://github.com/GoogleChrome/puppeteer) to launch a headless Chrome browser.  The URLs defined in the configuration file are each loaded once, and after page load the applicable tests are executed.  Test results are `passed` or `failed`, but can be configured to report `warning` instead of failure.  Only a `failed` test will cause the test process to fail and exit with an error code (a `warning` will not).
+The tests use [Puppeteer](https://github.com/GoogleChrome/puppeteer) to launch a headless Chrome browser. The URLs defined in the configuration file are each loaded once, and after page load the applicable tests are executed. Test results are `passed` or `failed`, but can be configured to report `warning` instead of failure. Only a `failed` test will cause the test process to fail and exit with an error code (a `warning` will not).
 
 ### Horizontal Scrollbar Test
 
-The horizontal scrollbar test fails if the rendered page has a horizontal scrollbar.  If a specific browser viewport size is desired for this test, that can be configured in the `puppeteerLaunchOptions`.
+The horizontal scrollbar test fails if the rendered page has a horizontal scrollbar. If a specific browser viewport size is desired for this test, that can be configured in the `puppeteerLaunchOptions`.
 
 ### Console Output Test
 
-The console output test fails if any output is written to the browser console.  An array is included in the report with all entries, as shown below:
+The console output test fails if any output is written to the browser console. An array is included in the report with all entries, as shown below:
 
 ```json
 [
-    {
-        "_args": [],
-        "_location": {
-            "lineNumber": undefined,
-            "url": "https://this.url.does.not.exist/file.js"
-        },
-        "_text": "Failed to load resource: net::ERR_NAME_NOT_RESOLVED",
-        "_type": "error"
-    }
+  {
+    "_args": [],
+    "_location": {
+      "lineNumber": undefined,
+      "url": "https://this.url.does.not.exist/file.js"
+    },
+    "_text": "Failed to load resource: net::ERR_NAME_NOT_RESOLVED",
+    "_type": "error"
+  }
 ]
 ```
 
 ### Console Error Test
 
-The console error test fails if any error is written to the browser console, but is otherwise the same as the console output test.  This separation allows for testing for console errors, but allowing any other console output.
+The console error test fails if any error is written to the browser console, but is otherwise the same as the console output test. This separation allows for testing for console errors, but allowing any other console output.
 
 ### Rendered HTML Test
 
-The rendered HTML test is intended for cases where content is dynamically created prior to page load (i.e. the `load` event firing).  The rendered HTML is returned and checked with [HTML Hint](https://www.npmjs.com/package/htmlhint) and the test fails if any issues are found.  An array is included in the report with all HTML Hint issues, as shown below:
+The rendered HTML test is intended for cases where content is dynamically created prior to page load (i.e. the `load` event firing). The rendered HTML is returned and checked with [HTML Hint](https://www.npmjs.com/package/htmlhint) and the test fails if any issues are found. An array is included in the report with all HTML Hint issues, as shown below:
 
 ```json
 [
-    {
-        "col": 9,
-        "evidence": "    <div id=\"div1\"></div>",
-        "line": 6,
-        "message": "The id value [ div1 ] must be unique.",
-        "raw": " id=\"div1\"",
-        "rule": {
-            "description": "The value of id attributes must be unique.",
-            "id": "id-unique",
-            "link": "https://github.com/thedaviddias/HTMLHint/wiki/id-unique"
-        },
-        "type": "error"
-    }
+  {
+    "col": 9,
+    "evidence": "    <div id=\"div1\"></div>",
+    "line": 6,
+    "message": "The id value [ div1 ] must be unique.",
+    "raw": " id=\"div1\"",
+    "rule": {
+      "description": "The value of id attributes must be unique.",
+      "id": "id-unique",
+      "link": "https://github.com/thedaviddias/HTMLHint/wiki/id-unique"
+    },
+    "type": "error"
+  }
 ]
 ```
 
@@ -87,28 +87,28 @@ Note: This test may not find some errors in the original HTML that are removed/r
 
 ### Page Load Time Test
 
-The page load time test fails if the page load time (from start through the `load` event) exceeds the defined threshold in the configuration file (or the default of 2 seconds).  The actual load time is included in the report.  Tests will time out at twice the page load time threshold.
+The page load time test fails if the page load time (from start through the `load` event) exceeds the defined threshold in the configuration file (or the default of 2 seconds). The actual load time is included in the report. Tests will time out at twice the page load time threshold.
 
 ### External Script Test
 
-The external script test is intended to identify any externally loaded javascript files (e.g. loaded from a CDN) and aggregate those files so they can undergo further analysis (e.g. dependency vulnerability scanning). The test is included here since these tests load fully rendered pages, therefore allowing the aggregation of this data for pages generated using any language or framework.  By default the test returns a warning if the page includes any javascript files loaded from a different domain than the page (although this could be overridden to fail instead via setting `failWarn: false`, see the Configuration section below).  These files are then downloaded and saved in the "pagean-external-files" directory in the project root.  Subdirectories are created for each domain, then following the URL path.  For example, the following script...
+The external script test is intended to identify any externally loaded javascript files (e.g. loaded from a CDN) and aggregate those files so they can undergo further analysis (e.g. dependency vulnerability scanning). The test is included here since these tests load fully rendered pages, therefore allowing the aggregation of this data for pages generated using any language or framework. By default the test returns a warning if the page includes any javascript files loaded from a different domain than the page (although this could be overridden to fail instead via setting `failWarn: false`, see the Configuration section below). These files are then downloaded and saved in the "pagean-external-files" directory in the project root. Subdirectories are created for each domain, then following the URL path. For example, the following script...
 
 ```html
 <script src="https://bootstrapcdn.com/bootstrap/4.5.0/js/bootstrap.min.js"></script>
 ```
 
-...will be saved as `./bootstrapcdn.com/bootstrap/4.5.0/js/bootstrap.min.js`.  The `data` array in the test report includes the original file URL and the local saved filename or applicable error, as shown below.
+...will be saved as `./bootstrapcdn.com/bootstrap/4.5.0/js/bootstrap.min.js`. The `data` array in the test report includes the original file URL and the local saved filename or applicable error, as shown below.
 
 ```json
 [
-    {
-        "url": "https://code.jquery.com/jquery-3.4.1.slim.min.js",
-        "localFile": "pagean-external-scripts/code.jquery.com/jquery-3.4.1.slim.min.js"
-    },
-    {
-        "url": "http://bootstrapcdn.com/bootstrap/4.5.0/js/bootstrap.min.js",
-        "error": "Request failed with status code 404"
-    }
+  {
+    "url": "https://code.jquery.com/jquery-3.4.1.slim.min.js",
+    "localFile": "pagean-external-scripts/code.jquery.com/jquery-3.4.1.slim.min.js"
+  },
+  {
+    "url": "http://bootstrapcdn.com/bootstrap/4.5.0/js/bootstrap.min.js",
+    "error": "Request failed with status code 404"
+  }
 ]
 ```
 
@@ -118,8 +118,8 @@ Each external script is saved only once, but will be reported on any page where
 
 The broken link test checks for broken links on the page. It checks any `<a>` tag on the page with `href` pointing to another location on the current page or another page (i.e. only `http(s)` or `file` protocols).
 
-- For links within the page, this test checks for existence of the element on the page, passing if the element exists and failing otherwise (and passing for cases that are always valid, e.g. `#` or `#top` for the current page).  It does not check the visibility of the element. Failing tests return a response of "#element Not Found" (where `#element` identifies the specific element).
-- For links to other pages, the test tries to most efficiently confirm whether the target link is valid. It first makes a `HEAD` request for that URL and checks the response.  If an erroneous response is returned (>= 400 with no execution error) and not code 429 (Too Many Requests), the request is retried with a `GET` request.  The test passes for HTTP responses < 400 and fails otherwise (if HTTP response is >= 400 or another error occurs).
+- For links within the page, this test checks for existence of the element on the page, passing if the element exists and failing otherwise (and passing for cases that are always valid, e.g. `#` or `#top` for the current page). It does not check the visibility of the element. Failing tests return a response of "#element Not Found" (where `#element` identifies the specific element).
+- For links to other pages, the test tries to most efficiently confirm whether the target link is valid. It first makes a `HEAD` request for that URL and checks the response. If an erroneous response is returned (>= 400 with no execution error) and not code 429 (Too Many Requests), the request is retried with a `GET` request. The test passes for HTTP responses < 400 and fails otherwise (if HTTP response is >= 400 or another error occurs).
   - This can result in false failure indications, specifically for `file://` links (`404` or `ECONNREFUSED`) or where the browser passes a domain identity with the request (page loads when tested, but `401` response for links to that page). For these cases, or other false failures, the test configuration allows a boolean `checkWithBrowser` option that will instead check links by loading the target in the browser (via `puppeteer`). Note this can increase test execution time, in some cases substantially, due to the time to open a new browser tab and plus load the page and all assets.
   - If the link to another page includes a hash it is removed prior to checking. The test in this case is confirming a valid link, not that the element exists, which is only done for the current page.
   - The test configuration allows an `ignoredLinks` array listing link URLs to ignore for this test. Note this only applies to links to other pages, not links within the page, which are always checked.
@@ -129,18 +129,18 @@ For any failing test, the `data` array in the test report includes the original
 
 ```json
 [
-    {
-        "href": "https://about.gitlab.com/not-found",
-        "status": 404
-    },
-    {
-        "href": "http://localhost:8080/brokenLinks.html#notlinked",
-        "status": "#notlinked Not Found"
-    },
-    {
-        "href": "https://this.url.does.not.exist/",
-        "status": "ENOTFOUND"
-    }
+  {
+    "href": "https://about.gitlab.com/not-found",
+    "status": 404
+  },
+  {
+    "href": "http://localhost:8080/brokenLinks.html#notlinked",
+    "status": "#notlinked Not Found"
+  },
+  {
+    "href": "https://this.url.does.not.exist/",
+    "status": "ENOTFOUND"
+  }
 ]
 ```
 
@@ -161,19 +161,19 @@ Complete reports for the example case in this project (the tests as specified in
 
 ## Configuration
 
-Pagean looks for a configuration file as specified via the CLI, or defaults to a file named `.pageanrc.json` in the project root.  If the configuration file is not found, is not valid JSON, or does not contain any URLs to check the job will fail.
+Pagean looks for a configuration file as specified via the CLI, or defaults to a file named `.pageanrc.json` in the project root. If the configuration file is not found, is not valid JSON, or does not contain any URLs to check the job will fail.
 
 Below is an example `.pageanrc.json` file, which is broken into six major properties:
 
 - `htmlhintrc`: An optional path to an htmlhintrc file to be used in the rendered HTML test
 - `project`: An optional name of the project, which is included in HTML and JSON reports.
-- `puppeteerLaunchOptions`: An optional set of options to pass to Puppeteer on launch.  There are no default options. The complete list of available options can be found at https://github.com/GoogleChrome/puppeteer/blob/master/docs/api.md#puppeteerlaunchoptions.
-- `reporters`:  An optional array of reporters indicating the test reports that should be provided.  There are three possible options - `cli`, `html`, and `json`. The `cli` option reports all test details to the console, but the final results summary is always output (even with `cli` disabled).  If `reporters` is specified, at least one reporter must be included. The default value, as specified below, is all three reporters enabled.
+- `puppeteerLaunchOptions`: An optional set of options to pass to Puppeteer on launch. There are no default options. The complete list of available options can be found at https://github.com/GoogleChrome/puppeteer/blob/master/docs/api.md#puppeteerlaunchoptions.
+- `reporters`: An optional array of reporters indicating the test reports that should be provided. There are three possible options - `cli`, `html`, and `json`. The `cli` option reports all test details to the console, but the final results summary is always output (even with `cli` disabled). If `reporters` is specified, at least one reporter must be included. The default value, as specified below, is all three reporters enabled.
 - `settings`: These settings enable/disable or configure tests, and are applied to all tests overriding the default values.
-  - The shorthand notation allows easy enabling/disabling of tests. In this format the test name is given with a boolean value to enable or disable the test.  In this case any other test-specific settings use the default values.
+  - The shorthand notation allows easy enabling/disabling of tests. In this format the test name is given with a boolean value to enable or disable the test. In this case any other test-specific settings use the default values.
   - The longhand version includes an object for each test. Every test includes two possible properties (some tests include additional settings):
     - `enabled`: A boolean value to enable/disable the test, and some tests include additional settings (default `true` for all tests).
-    - `failWarn`: A boolean value causing a failed test to report a warning instead of failure.  A warning result will not cause the test process to fail (exit with an error code).  The default value for all tests is `false` except the `externalScriptTest`, as shown below.
+    - `failWarn`: A boolean value causing a failed test to report a warning instead of failure. A warning result will not cause the test process to fail (exit with an error code). The default value for all tests is `false` except the `externalScriptTest`, as shown below.
 
 The shorthand:
 
@@ -196,67 +196,63 @@ is equivalent to the longhand:
 
 All available settings with the default values are shown below.
 
-- `urls`: An array of URLs to be tested, which must contain at least one value.  Each array entry can either be a URL string, or an object that contains a `url` string and an optional `settings` object.  This object can contain any of the `settings` values identified above and will override that setting for testing that URL.  The `url` string can be either an actual URL or a local file, as shown in the example below.
+- `urls`: An array of URLs to be tested, which must contain at least one value. Each array entry can either be a URL string, or an object that contains a `url` string and an optional `settings` object. This object can contain any of the `settings` values identified above and will override that setting for testing that URL. The `url` string can be either an actual URL or a local file, as shown in the example below.
 
 ```json
 {
-    "puppeteerLaunchOptions": {
-        "args": [ "--no-sandbox" ]
+  "puppeteerLaunchOptions": {
+    "args": ["--no-sandbox"]
+  },
+  "reporters": ["cli", "html", "json"],
+  "settings": {
+    "horizontalScrollbarTest": {
+      "enabled": true,
+      "failWarn": false
+    },
+    "consoleOutputTest": {
+      "enabled": true,
+      "failWarn": false
+    },
+    "consoleErrorTest": {
+      "enabled": true,
+      "failWarn": false
+    },
+    "renderedHtmlTest": {
+      "enabled": true,
+      "failWarn": false
+    },
+    "pageLoadTimeTest": {
+      "enabled": true,
+      "failWarn": false,
+      "pageLoadTimeThreshold": 2
     },
-    "reporters": [
-        "cli",
-        "html",
-        "json"
-    ],
-    "settings": {
-        "horizontalScrollbarTest": {
-            "enabled": true,
-            "failWarn": false
-        },
-        "consoleOutputTest":  {
-            "enabled": true,
-            "failWarn": false
-        },
-        "consoleErrorTest":  {
-            "enabled": true,
-            "failWarn": false
-        },
-        "renderedHtmlTest":  {
-            "enabled": true,
-            "failWarn": false
-        },
-        "pageLoadTimeTest":  {
-            "enabled": true,
-            "failWarn": false,
-            "pageLoadTimeThreshold": 2
-        },
-        "externalScriptTest":  {
-            "enabled": true,
-            "failWarn": true
-        },
-        "brokenLinkTest": {
-            "enabled": true,
-            "failWarn": false,
-            "checkWithBrowser": false,
-            "ignoreDuplicates": true,
-            "ignoredLinks": []
-        }
+    "externalScriptTest": {
+      "enabled": true,
+      "failWarn": true
     },
-    "urls": [
-        "https://gitlab.com/gitlab-ci-utils/pagean/",
-        {
-            "url": "./tests/test-cases/consoleLog.html",
-            "settings": {
-                "consoleOutputTest": false
-            }
-        }
-    ]
+    "brokenLinkTest": {
+      "enabled": true,
+      "failWarn": false,
+      "checkWithBrowser": false,
+      "ignoreDuplicates": true,
+      "ignoredLinks": []
+    }
+  },
+  "urls": [
+    "https://gitlab.com/gitlab-ci-utils/pagean/",
+    {
+      "url": "./tests/test-cases/consoleLog.html",
+      "settings": {
+        "consoleOutputTest": false
+      }
+    }
+  ]
 }
 ```
 
 ## Docker Images
 
-Provided with the Pagean project are Docker images configured to run the tests.  All available image tags can be found in the `gitlab-ci-utils/pagean` repository at https://gitlab.com/gitlab-ci-utils/pagean/container_registry.  Details on each release can be found on the [Releases](https://gitlab.com/gitlab-ci-utils/pagean/releases) page.
+Provided with the Pagean project are Docker images configured to run the tests. All available image tags can be found in the `gitlab-ci-utils/pagean` repository at https://gitlab.com/gitlab-ci-utils/pagean/container_registry. Details on each release can be found on the [Releases](https://gitlab.com/gitlab-ci-utils/pagean/releases) page.
 
 **Note:** Any images in the `gitlab-ci-utils/pagean/tmp` repository are temporary images used during the build process and may be deleted at any point.
 
@@ -280,7 +276,7 @@ pagean:
 
 ### Testing With Static HTTP Server
 
-The Docker image shown above includes [`http-server`](https://www.npmjs.com/package/http-server) and [`wait-on`](https://www.npmjs.com/package/wait-on) installed globally to run a local HTTP server for testing static content.  The example job below illustrates how to use this for Pagean tests.  The script starts the server in this project's `test-cases` directory and uses `wait-on` to hold the script until the server is running and returns a valid response. The referenced `pageanrc` file is the same as the project default `pageanrc`, but references all test URLs from the local server.
+The Docker image shown above includes [`http-server`](https://www.npmjs.com/package/http-server) and [`wait-on`](https://www.npmjs.com/package/wait-on) installed globally to run a local HTTP server for testing static content. The example job below illustrates how to use this for Pagean tests. The script starts the server in this project's `test-cases` directory and uses `wait-on` to hold the script until the server is running and returns a valid response. The referenced `pageanrc` file is the same as the project default `pageanrc`, but references all test URLs from the local server.
 
 ```yaml
 pagean:

package/bin/pagean.js

@@ -9,17 +9,24 @@ const pkg = require('../package.json');
 
 const defaultConfigFileName = './.pageanrc.json';
 
-program.version(pkg.version)
-    .option('-c, --config <file>',
+program
+    .version(pkg.version)
+    .option(
+        '-c, --config <file>',
         'the path to the pagean configuration file',
-        defaultConfigFileName)
+        defaultConfigFileName
+    )
     .parse(process.argv);
 const options = program.opts();
 
 try {
     const config = getConfig(options.config);
     pagean.executeAllTests(config);
-}
-catch (error) {
-    log({ message: `Error executing pagean tests\n${error.message}`, level: levels.error, exitOnError: true, errorCode: 1 });
+} catch (error) {
+    log({
+        message: `Error executing pagean tests\n${error.message}`,
+        level: levels.error,
+        exitOnError: true,
+        errorCode: 1
+    });
 }

package/bin/pageanrc-lint.js

@@ -10,7 +10,8 @@ const pkg = require('../package.json');
 
 const defaultConfigFileName = './.pageanrc.json';
 
-program.version(pkg.version)
+program
+    .version(pkg.version)
     .option('-j, --json', 'output JSON with full details')
     .description('Lint a pageanrc file')
     .usage(`[options] [file] (default: "${defaultConfigFileName}")`)
@@ -34,8 +35,7 @@ const outputJsonResults = (configFileName, lintResults) => {
 const outputConsoleResults = (configFileName, lintResults) => {
     if (lintResults.isValid) {
         log({ message: `\n${configFileName}: ${green('valid')}\n` });
-    }
-    else {
+    } else {
         logError(`\n${underline(configFileName)}`, false);
         for (const error of formatErrors(lintResults.errors)) {
             logError(error, false);
@@ -46,16 +46,15 @@ const outputConsoleResults = (configFileName, lintResults) => {
 };
 
 try {
-    const configFileName = program.args.length > 0 ? program.args[0] : defaultConfigFileName;
+    const configFileName =
+        program.args.length > 0 ? program.args[0] : defaultConfigFileName;
     const lintResults = lintConfigFile(configFileName);
 
     if (options.json) {
         outputJsonResults(configFileName, lintResults);
-    }
-    else {
+    } else {
         outputConsoleResults(configFileName, lintResults);
     }
-}
-catch (error) {
+} catch (error) {
     logError(`Error linting pageanrc file\n${error.message}`);
 }

package/docs/upgrade-guide.md

@@ -26,18 +26,18 @@
 
 ```json
 {
-    "settings": {
-        "pageLoadTimeThreshold": 2
-    },
-    "urls": [
-        "https://somewhere.com/",
-        {
-            "url": "https://somewhere-else.com",
-            "settings": {
-                "pageLoadTimeThreshold": 3
-            }
-        }
-    ]
+  "settings": {
+    "pageLoadTimeThreshold": 2
+  },
+  "urls": [
+    "https://somewhere.com/",
+    {
+      "url": "https://somewhere-else.com",
+      "settings": {
+        "pageLoadTimeThreshold": 3
+      }
+    }
+  ]
 }
 ```
 
@@ -45,21 +45,21 @@
 
 ```json
 {
-    "settings": {
+  "settings": {
+    "pageLoadTimeTest": {
+      "pageLoadTimeThreshold": 2
+    }
+  },
+  "urls": [
+    "https://somewhere.com/",
+    {
+      "url": "https://somewhere-else.com",
+      "settings": {
         "pageLoadTimeTest": {
-            "pageLoadTimeThreshold": 2
-        }
-    },
-    "urls": [
-        "https://somewhere.com/",
-        {
-            "url": "https://somewhere-else.com",
-            "settings": {
-                "pageLoadTimeTest": {
-                    "pageLoadTimeThreshold": 3
-                }
-            }
+          "pageLoadTimeThreshold": 3
         }
-    ]
+      }
+    }
+  ]
 }
 ```

package/index.js

@@ -18,6 +18,7 @@ const { createLinkChecker } = require('./lib/link-utils');
  * @static
  * @param {object} config The Pagean test configuration.
  */
+// eslint-disable-next-line max-lines-per-function
 const executeAllTests = async (config) => {
     const logger = testLogger(config);
     const linkChecker = createLinkChecker();
@@ -29,13 +30,27 @@ const executeAllTests = async (config) => {
         const consoleLog = [];
         const page = await browser.newPage();
         // Object property names defined by puppeteer API
-        // eslint-disable-next-line no-underscore-dangle
-        page.on('console', message => consoleLog.push({ _type: message._type, _text: message._text, _stackTraceLocations: message._stackTraceLocations }));
+        page.on('console', (message) =>
+            consoleLog.push({
+                // eslint-disable-next-line no-underscore-dangle
+                _type: message._type,
+                // eslint-disable-next-line no-underscore-dangle
+                _text: message._text,
+                // eslint-disable-next-line no-underscore-dangle
+                _stackTraceLocations: message._stackTraceLocations
+            })
+        );
         await page.goto(testUrl.url, { waitUntil: 'load' });
 
         const testContext = {
-            page, consoleLog,
-            urlSettings: { ...testUrl.settings, htmlHintConfig: config.htmlHintConfig }, logger, linkChecker
+            page,
+            consoleLog,
+            urlSettings: {
+                ...testUrl.settings,
+                htmlHintConfig: config.htmlHintConfig
+            },
+            logger,
+            linkChecker
         };
         for (const test of Object.keys(testFunctions)) {
             await testFunctions[test](testContext);

package/lib/config.js

@@ -22,8 +22,7 @@ const getUrl = (testUrl) => {
     if (typeof testUrl === 'object') {
         rawUrl = testUrl.url;
         urlSettings = testUrl.settings;
-    }
-    else {
+    } else {
         rawUrl = testUrl;
     }
     return { rawUrl, urlSettings };
@@ -47,27 +46,42 @@ const processAllTestSettings = (settings) => {
     return processedSettings;
 };
 
-const consolidateTestSettings = (defaultSettings, globalSettings, urlSettings) => {
+const consolidateTestSettings = (
+    defaultSettings,
+    globalSettings,
+    urlSettings
+) => {
     const sanitizedGlobalSettings = globalSettings ? globalSettings : {};
     const sanitizedUrlSettings = urlSettings ? urlSettings : {};
     const processedSettings = {};
     for (const key of Object.keys(defaultSettings)) {
-        processedSettings[key] = { ...defaultSettings[key], ...sanitizedGlobalSettings[key], ...sanitizedUrlSettings[key] };
+        processedSettings[key] = {
+            ...defaultSettings[key],
+            ...sanitizedGlobalSettings[key],
+            ...sanitizedUrlSettings[key]
+        };
     }
     if (processedSettings.brokenLinkTest.ignoredLinks) {
-        processedSettings.brokenLinkTest.ignoredLinks = processedSettings.brokenLinkTest.ignoredLinks.map(link => normalizeLink(link));
+        processedSettings.brokenLinkTest.ignoredLinks =
+            processedSettings.brokenLinkTest.ignoredLinks.map((link) =>
+                normalizeLink(link)
+            );
     }
     return processedSettings;
 };
 
 const processUrls = (config) => {
     const processedConfigSettings = processAllTestSettings(config.settings);
-    return config.urls.map(testUrl => {
+    return config.urls.map((testUrl) => {
         const { rawUrl, urlSettings } = getUrl(testUrl);
         return {
             url: protocolify(rawUrl),
             rawUrl,
-            settings: consolidateTestSettings(defaultConfig.settings, processedConfigSettings, processAllTestSettings(urlSettings))
+            settings: consolidateTestSettings(
+                defaultConfig.settings,
+                processedConfigSettings,
+                processAllTestSettings(urlSettings)
+            )
         };
     });
 };
@@ -76,11 +90,15 @@ const getHtmlHintConfig = (htmlHintConfigFilename) => {
     if (!fs.existsSync(htmlHintConfigFilename)) {
         return;
     }
-    return JSON.parse(fs.readFileSync(htmlHintConfigFilename, 'utf-8'));
+    return JSON.parse(fs.readFileSync(htmlHintConfigFilename, 'utf8'));
 };
 
 const validateConfigSchema = (config) => {
-    const schema = JSON.parse(fs.readFileSync(path.join(__dirname, '../', 'schemas', 'pageanrc.schema.json')));
+    const schema = JSON.parse(
+        fs.readFileSync(
+            path.join(__dirname, '../', 'schemas', 'pageanrc.schema.json')
+        )
+    );
     const ajv = new Ajv({ allErrors: true });
     ajvErrors(ajv);
     const validate = ajv.compile(schema);
@@ -89,7 +107,7 @@ const validateConfigSchema = (config) => {
 };
 
 const getConfigFromFile = (configFileName) => {
-    return JSON.parse(fs.readFileSync(configFileName, 'utf-8'));
+    return JSON.parse(fs.readFileSync(configFileName, 'utf8'));
 };
 
 /**
@@ -104,13 +122,17 @@ const processConfig = (configFileName) => {
     const config = getConfigFromFile(configFileName);
     const { isValid } = validateConfigSchema(config);
     if (!isValid) {
-        throw new TypeError(`File ${configFileName} has an invalid pageanrc schema`);
+        throw new TypeError(
+            `File ${configFileName} has an invalid pageanrc schema`
+        );
     }
     return {
         project: config.project || '',
         puppeteerLaunchOptions: config.puppeteerLaunchOptions,
         urls: processUrls(config),
-        htmlHintConfig: getHtmlHintConfig(config.htmlhintrc || defaultHtmlHintConfigFilename),
+        htmlHintConfig: getHtmlHintConfig(
+            config.htmlhintrc || defaultHtmlHintConfigFilename
+        ),
         reporters: config.reporters ? config.reporters : defaultConfig.reporters
     };
 };

package/lib/default-config.json

@@ -32,12 +32,6 @@
       "ignoreDuplicates": true
     }
   },
-  "reporters": [
-    "cli",
-    "html",
-    "json"
-  ],
-  "urls": [
-    "ignored, required to validate schema"
-  ]
+  "reporters": ["cli", "html", "json"],
+  "urls": ["ignored, required to validate schema"]
 }

package/lib/external-file-utils.js

@@ -39,7 +39,11 @@ const saveExternalScript = async (script) => {
     const result = { url: script };
     try {
         const scriptUrl = new URL(script);
-        const pathName = path.join(externalFilePath, scriptUrl.hostname, scriptUrl.pathname);
+        const pathName = path.join(
+            externalFilePath,
+            scriptUrl.hostname,
+            scriptUrl.pathname
+        );
         if (!fs.existsSync(pathName)) {
             // Axios will throw for any error response
             const response = await axios.get(script);
@@ -47,8 +51,7 @@ const saveExternalScript = async (script) => {
             fs.writeFileSync(pathName, response.data);
         }
         result.localFile = pathName;
-    }
-    catch (error) {
+    } catch (error) {
         result.error = error.message;
     }
     return result;