pagean 6.0.7 → 7.0.0

package/lib/config.js

@@ -12,7 +12,7 @@ const Ajv = require('ajv').default;
 const ajvErrors = require('ajv-errors');
 const protocolify = require('protocolify');
 
-const { normalizeLink } = require('./linkUtils');
+const { normalizeLink } = require('./link-utils');
 
 const defaultConfig = require('./default-config.json');
 const defaultHtmlHintConfigFilename = './.htmlhintrc';
@@ -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/{externalFileUtils.js → 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,9 +51,8 @@ const saveExternalScript = async (script) => {
             fs.writeFileSync(pathName, response.data);
         }
         result.localFile = pathName;
-    }
-    catch (err) {
-        result.error = err.message;
+    } catch (error) {
+        result.error = error.message;
     }
     return result;
 };

package/lib/{linkUtils.js → link-utils.js}

@@ -3,7 +3,7 @@
 /**
  * Utilities for checking page links.
  *
- * @module linkUtils
+ * @module link-utils
  */
 
 const https = require('https');
@@ -29,12 +29,12 @@ const httpResponse = Object.freeze({
     unknownError: 999
 });
 
-const noRetryResponses = [httpResponse.tooManyRequests];
+const noRetryResponses = new Set([httpResponse.tooManyRequests]);
 
-// eslint-disable-next-line jsdoc/require-description-complete-sentence
+/* eslint-disable jsdoc/require-description-complete-sentence */
 /**
- * Normalizes a URL with https://www.npmjs.com/package/normalize-url
- * using defaults plus the following overrides:
+ * Normalizes a URL (with https://www.npmjs.com/package/normalize-url).
+ * Uses defaults plus the following overrides.
  *  1. Set default protocol to https if protocol-relative
  *  2. Do not remove any querystring parameters
  *  3. Strip hash from URL
@@ -42,17 +42,17 @@ const noRetryResponses = [httpResponse.tooManyRequests];
  *
  * @public
  * @static
- * @param {string} url  The URL to normalize.
- * @returns {string}    The normalized URL.
+ * @param   {string} url  The URL to normalize.
+ * @returns {string}      The normalized URL.
  */
-const normalizeLink = url => normalizeUrl(url,
-    {
+const normalizeLink = (url) =>
+    normalizeUrl(url, {
         defaultProtocol: 'https:',
         removeQueryParameters: [],
         stripHash: true,
         stripWWW: false
     });
-
+/* eslint-enable jsdoc/require-description-complete-sentence */
 
 /**
  * Checks settings to determine if the provided link should be ignored.
@@ -64,8 +64,8 @@ const normalizeLink = url => normalizeUrl(url,
  * @param   {string} link     The link to check against the ignore list.
  * @returns {boolean}         True if the link should be ignored, otherwise false.
  */
-const ignoreLink = (settings, link) => settings.ignoredLinks && settings.ignoredLinks.includes(link);
-
+const ignoreLink = (settings, link) =>
+    settings.ignoredLinks && settings.ignoredLinks.includes(link);
 
 /**
  * Checks a response to an HTTP request, either a response code or explicit error,
@@ -76,8 +76,9 @@ const ignoreLink = (settings, link) => settings.ignoredLinks && settings.ignored
  * @param   {(string|number)} response The response to an HTTP request to check for failure.
  * @returns {boolean}                  True if failed, otherwise false.
  */
-const isFailedResponse = response => isNaN(response.status) || response.status >= httpResponse.badRequest;
-
+const isFailedResponse = (response) =>
+    Number.isNaN(Number(response.status)) ||
+    response.status >= httpResponse.badRequest;
 
 /**
  * Checks a Puppeteer page for the element specified in the hash of the provided link.
@@ -98,7 +99,6 @@ const checkSamePageLink = async (page, link) => {
     return element ? httpResponse.ok : `${selector} Not Found`;
 };
 
-
 /**
  * Checks the provided link for validity by loading in a Puppeteer page.
  *
@@ -115,16 +115,14 @@ const checkExternalPageLinkBrowser = async (page, link) => {
         const response = await testPage.goto(link);
         status = response.status();
         await testPage.close();
-    }
-    catch (err) {
+    } catch (error) {
         // Errors are returned in the format: "ENOTFOUND at https://this.url.does.not.exist/",
         // so extract error only and remove URL
-        status = err.message.replace(/^(.*) at .*$/, '$1');
+        status = error.message.replace(/^(.*) at .*$/, '$1');
     }
     return status;
 };
 
-
 /**
  * Checks the provided link for validity by requesting with axios. If useGet if false,
  * a HEAD request is made for efficiency. If useGet is true, a full GET request is made.
@@ -142,7 +140,10 @@ const checkExternalPageLink = async (page, link, useGet = false) => {
     const userAgent = await page.evaluate('navigator.userAgent');
 
     try {
-        const options = { headers: { 'User-Agent': userAgent }, timeout: timeoutSeconds * msPerSec };
+        const options = {
+            headers: { 'User-Agent': userAgent },
+            timeout: timeoutSeconds * msPerSec
+        };
         // Using internal browser property since not exposed
         // eslint-disable-next-line no-underscore-dangle
         if (page.browser()._ignoreHTTPSErrors) {
@@ -152,22 +153,24 @@ const checkExternalPageLink = async (page, link, useGet = false) => {
         const httpMethod = useGet ? axios.get : axios.head;
         const response = await httpMethod(link, options);
         return response.status;
-    }
-    catch (err) {
+    } catch (error) {
         // Some servers respond invalid for head request (e.g. a lot of 405 Method
         // Not Allowed), so if a response was returned, is not a response that should
         // skip a retry (e.g. 429), and the request was head then retry with get.
-        if (err.response && !noRetryResponses.includes(err.response.status) && !useGet) {
+        if (
+            error.response &&
+            !noRetryResponses.has(error.response.status) &&
+            !useGet
+        ) {
             return checkExternalPageLink(page, link, true);
         }
 
         // Axios will throw for failed response (code >= 400), so return
         // that response code or the error code if execution error
-        return err.response ? err.response.status : err.code;
+        return error.response ? error.response.status : error.code;
     }
 };
 
-
 /**
  * Factory function returning a linkChecker object with a {@link checkLink}
  * function that caches checked link results.
@@ -176,7 +179,6 @@ const checkExternalPageLink = async (page, link, useGet = false) => {
  * @static
  * @returns {object} Link checker object.
  */
-// eslint-disable-next-line max-lines-per-function
 const createLinkChecker = () => {
     const checkedLinks = new Map();
 
@@ -206,18 +208,17 @@ const createLinkChecker = () => {
                     return httpResponse.continue;
                 }
 
-                if (context.testSettings.ignoreDuplicates && checkedLinks.has(link)) {
+                if (
+                    context.testSettings.ignoreDuplicates &&
+                    checkedLinks.has(link)
+                ) {
                     return checkedLinks.get(link);
                 }
 
-                if (context.testSettings.checkWithBrowser) {
-                    status = await checkExternalPageLinkBrowser(context.page, normalizedLink);
-                }
-                else {
-                    status = await checkExternalPageLink(context.page, normalizedLink);
-                }
-            }
-            catch {
+                status = await (context.testSettings.checkWithBrowser
+                    ? checkExternalPageLinkBrowser(context.page, normalizedLink)
+                    : checkExternalPageLink(context.page, normalizedLink));
+            } catch {
                 status = httpResponse.unknownError;
             }
 

package/lib/logger.js

@@ -15,7 +15,7 @@ const testResultSymbols = Object.freeze({
     warning: ' ‼'
 });
 
-const nullFunction = () => { };
+const nullFunction = () => {};
 
 /**
  * Factory function that creates an instance of a
@@ -29,7 +29,9 @@ const nullFunction = () => { };
 module.exports = (config) => {
     const cliReporter = {
         // If cli reporter is enabled, set console log function, otherwise null function
-        log: config.reporters.includes(reporterTypes.cli) ? consoleLogger.log : nullFunction,
+        log: config.reporters.includes(reporterTypes.cli)
+            ? consoleLogger.log
+            : nullFunction,
         // The logAlways function provides a mechanism to log to the console even
         // when the cli reporter is disabled (e.g. returning the final results)
         logAlways: consoleLogger.log
@@ -87,7 +89,9 @@ module.exports = (config) => {
     };
 
     const outputTestSummary = () => {
-        cliReporter.logAlways({ message: `\n Tests: ${testResults.summary.tests}\n Passed: ${testResults.summary.passed}\n Warning: ${testResults.summary.warning}\n Failed: ${testResults.summary.failed}\n` });
+        cliReporter.logAlways({
+            message: `\n Tests: ${testResults.summary.tests}\n Passed: ${testResults.summary.passed}\n Warning: ${testResults.summary.warning}\n Failed: ${testResults.summary.failed}\n`
+        });
     };
 
     /**

package/lib/reporter.js

@@ -19,8 +19,10 @@ handlebars.registerHelper('json', (context) => {
 });
 
 const saveHtmlReport = (results) => {
-    const templateFile = path.resolve(path.join(__dirname, htmlReportTemplateName));
-    const htmlReportTemplate = fs.readFileSync(templateFile, 'utf-8');
+    const templateFile = path.resolve(
+        path.join(__dirname, htmlReportTemplateName)
+    );
+    const htmlReportTemplate = fs.readFileSync(templateFile, 'utf8');
     const template = handlebars.compile(htmlReportTemplate);
     const htmlReport = template(results);
     fs.writeFileSync(htmlReportFileName, htmlReport);

package/lib/{schemaErrors.js → schema-errors.js}

@@ -16,14 +16,25 @@ const getDataKey = (instancePath) => {
     // Convert pointer to key be splitting by /, removing first value (since pointer
     // starts with /, so empty), unencoding values, and the re-assembling with different
     // formatting for numeric array indices versus properties.
-    return baseKey + instancePath.split('/').slice(1).reduce((accumulator, currentValue) => {
-        const unencodedValue = currentValue.replace(/~0/g, '~').replace(/~1/g, '/');
-        // eslint-disable-next-line sonarjs/no-nested-template-literals -- less intuitive
-        return `${accumulator}${isNaN(unencodedValue) ? `.${unencodedValue}` : `[${unencodedValue}]`}`;
-    }, '');
+    return (
+        baseKey +
+        instancePath
+            .split('/')
+            .slice(1)
+            // eslint-disable-next-line unicorn/no-array-reduce -- reduce for string concatenation
+            .reduce((accumulator, currentValue) => {
+                const unencodedValue = currentValue
+                    .replace(/~0/g, '~')
+                    .replace(/~1/g, '/');
+                const encodedValue = Number.isNaN(Number(unencodedValue))
+                    ? `.${unencodedValue}`
+                    : `[${unencodedValue}]`;
+                return `${accumulator}${encodedValue}`;
+            }, '')
+    );
 };
 
-const processErrorParams = (error) => {
+const processErrorParameters = (error) => {
     let formattedMessage = error.message;
     // Ajv includes all allowed values in params.allowedValues,
     // so add to message if available.
@@ -44,15 +55,20 @@ const processErrorParams = (error) => {
 const formatErrors = (errors) => {
     const margin = 2;
     let maxLength = 0;
-    errors.forEach(error => {
+    for (const error of errors) {
         error.dataKey = getDataKey(error.instancePath);
-        error.formattedMessage = processErrorParams(error);
+        error.formattedMessage = processErrorParameters(error);
         // Get max dataKey length for all errors to line up column in final output
         if (error.dataKey.length > maxLength) {
             maxLength = error.dataKey.length;
         }
-    });
-    return errors.map(error => `  ${error.dataKey.padEnd(maxLength + margin)}${red(error.formattedMessage)}`);
+    }
+    return errors.map(
+        (error) =>
+            `  ${error.dataKey.padEnd(maxLength + margin)}${red(
+                error.formattedMessage
+            )}`
+    );
 };
 
 module.exports.formatErrors = formatErrors;

package/lib/{testUtils.js → test-utils.js}

@@ -14,7 +14,9 @@ const testResultStates = Object.freeze({
 
 const getTestSettings = (testSettingProperty, urlSettings) => {
     if (urlSettings[testSettingProperty] === undefined) {
-        throw new Error(`Property '${testSettingProperty}' could not be found in test settings`);
+        throw new Error(
+            `Property '${testSettingProperty}' could not be found in test settings`
+        );
     }
     return urlSettings[testSettingProperty];
 };
@@ -31,19 +33,29 @@ const getTestSettings = (testSettingProperty, urlSettings) => {
  * @param {string}   testSettingProperty The name of the config property
  *                                       with settings for the current test.
  */
-// eslint-disable-next-line sonarjs/cognitive-complexity -- Allow < 10
-const pageanTest = async (name, testFunction, testContext, testSettingProperty) => {
-    const testSettings = getTestSettings(testSettingProperty, testContext.urlSettings);
+const pageanTest = async (
+    name,
+    testFunction,
+    testContext,
+    testSettingProperty
+    // eslint-disable-next-line sonarjs/cognitive-complexity -- Allow < 10
+) => {
+    const testSettings = getTestSettings(
+        testSettingProperty,
+        testContext.urlSettings
+    );
     testContext.testSettings = testSettings;
     if (testSettings.enabled) {
         let results;
         try {
             results = await testFunction(testContext);
+        } catch (error) {
+            results = { result: testResultStates.failed, data: { error } };
         }
-        catch (err) {
-            results = { result: testResultStates.failed, data: { error: err } };
-        }
-        if (results.result === testResultStates.failed && testSettings.failWarn) {
+        if (
+            results.result === testResultStates.failed &&
+            testSettings.failWarn
+        ) {
             results.result = testResultStates.warning;
         }
         testContext.logger.logTestResults({