pagean 4.4.2 → 6.0.1

package/tests/config.test.js

@@ -1,264 +0,0 @@
-'use strict';
-
-const fs = require('fs');
-const config = require('../lib/config');
-const defaultConfig = require('../lib/default-config.json');
-
-const nonExistentConfigFileName = 'not-a-file.json';
-const invalidConfigFileName = './tests/test-configs/unit-tests/invalid.pageanrc.json';
-const emptyConfigFileName = './tests/test-configs/unit-tests/empty.pageanrc.json';
-const emptyUrlsConfigFileName = './tests/test-configs/unit-tests/empty-urls.pageanrc.json';
-const emptyUrlValuesConfigFileName = './tests/test-configs/unit-tests/empty-url-values.pageanrc.json';
-const noTestSettingsConfigFileName = './tests/test-configs/unit-tests/no-test-settings.pageanrc.json';
-const globalTestSettingsConfigFileName = './tests/test-configs/unit-tests/global-test-settings.pageanrc.json';
-const testSpecificSettingsConfigFileName = './tests/test-configs/unit-tests/test-specific-settings.pageanrc.json';
-const globalAndTestSpecificSettingsConfigFileName = './tests/test-configs/unit-tests/global-and-test-specific-settings.pageanrc.json';
-const projectNoTestSettingsConfigFileName = './tests/test-configs/unit-tests/project-no-test-settings.pageanrc.json';
-const puppeteerNoTestSettingsConfigFileName = './tests/test-configs/unit-tests/puppeteer-no-test-settings.pageanrc.json';
-const urlTypesConfigFileName = './tests/test-configs/unit-tests/url-types.pageanrc.json';
-const allTestPropsConfigFileName = './tests/test-configs/unit-tests/global-and-test-specific-settings-test-props.pageanrc.json';
-const allShorthandConfigFileName = './tests/test-configs/unit-tests/global-and-test-specific-settings-shorthand.pageanrc.json';
-const reportersEmptyArrayConfigFileName = './tests/test-configs/unit-tests/reporters-empty.pageanrc.json';
-const reportersInvalidTypeConfigFileName = './tests/test-configs/unit-tests/reporters-invalid-type.pageanrc.json';
-const reportersNotArrayConfigFileName = './tests/test-configs/unit-tests/reporters-not-array.pageanrc.json';
-const reportersValidConfigFileName = './tests/test-configs/unit-tests/reporters-valid.pageanrc.json';
-const htmlhintrcInvalidConfigFileName = './tests/test-configs/unit-tests/htmlhintrc-invalid.pageanrc.json';
-const ignoredLinksDenormalizedConfigFileName = './tests/test-configs/unit-tests/ignored-links-denormalized.pageanrc.json';
-const htmlhintrcValidConfigFileName = './tests/test-configs/unit-tests/htmlhintrc-valid.pageanrc.json';
-const cliDefaultConfigFileName = './tests/test-configs/cli-tests/.pageanrc.json';
-
-// eslint-disable-next-line max-lines-per-function
-describe('process config', () => {
-    // eslint-disable-next-line max-lines-per-function
-    describe('invalid config', () => {
-        const invalidConfigMessage = 'invalid pageanrc schema';
-
-        it('should throw if config file not found', () => {
-            expect.assertions(1);
-            expect(() => config(nonExistentConfigFileName)).toThrow('ENOENT');
-        });
-
-        it('should throw if config file is not JSON', () => {
-            expect.assertions(1);
-            expect(() => config(invalidConfigFileName)).toThrow('Unexpected end of JSON input');
-        });
-
-        it('should throw if no URLs specified in config file', () => {
-            expect.assertions(1);
-            expect(() => config(emptyConfigFileName)).toThrow(invalidConfigMessage);
-        });
-
-        it('should throw if empty URL array specified in config file', () => {
-            expect.assertions(1);
-            expect(() => config(emptyUrlsConfigFileName)).toThrow(invalidConfigMessage);
-        });
-
-        it('should throw if URL object with no url property specified in config file', () => {
-            expect.assertions(1);
-            expect(() => config(emptyUrlValuesConfigFileName)).toThrow(invalidConfigMessage);
-        });
-
-        it('should throw if reporters specified in config are not array', () => {
-            expect.assertions(1);
-            expect(() => config(reportersNotArrayConfigFileName)).toThrow(invalidConfigMessage);
-        });
-
-        it('should throw if reporters specified in config are empty array', () => {
-            expect.assertions(1);
-            expect(() => config(reportersEmptyArrayConfigFileName)).toThrow(invalidConfigMessage);
-        });
-
-        it('should throw if reporters array specified in config has invalid values', () => {
-            expect.assertions(1);
-            expect(() => config(reportersInvalidTypeConfigFileName)).toThrow(invalidConfigMessage);
-        });
-    });
-
-    const checkConfigAgainstSnapshot = (configFileName, property) => {
-        expect.assertions(1);
-        const processedConfig = config(configFileName);
-        expect(processedConfig[property]).toMatchSnapshot();
-    };
-
-    describe('project name', () => {
-        it('should return config with project name if provided', () => {
-            expect.assertions(1);
-            const processedConfig = config(projectNoTestSettingsConfigFileName);
-            expect(processedConfig.project).toStrictEqual('This is a test project');
-        });
-
-        it('should return config with empty project name if none provided', () => {
-            expect.assertions(1);
-            const processedConfig = config(puppeteerNoTestSettingsConfigFileName);
-            expect(processedConfig.project).toStrictEqual('');
-        });
-    });
-
-    describe('puppeteer launch options', () => {
-        it('should return config with puppeteer launch settings', () => {
-            expect.hasAssertions();
-            checkConfigAgainstSnapshot(puppeteerNoTestSettingsConfigFileName, 'puppeteerLaunchOptions');
-        });
-
-        it('should return config with undefined puppeteer launch settings', () => {
-            expect.hasAssertions();
-            checkConfigAgainstSnapshot(noTestSettingsConfigFileName, 'puppeteerLaunchOptions');
-        });
-    });
-
-    // eslint-disable-next-line max-lines-per-function
-    describe('test settings', () => {
-        it('should return config with default test settings', () => {
-            expect.hasAssertions();
-            checkConfigAgainstSnapshot(noTestSettingsConfigFileName, 'urls');
-        });
-
-        it('should return config with global test settings', () => {
-            expect.hasAssertions();
-            checkConfigAgainstSnapshot(globalTestSettingsConfigFileName, 'urls');
-        });
-
-        it('should return config with default and test-specific settings', () => {
-            expect.hasAssertions();
-            checkConfigAgainstSnapshot(testSpecificSettingsConfigFileName, 'urls');
-        });
-
-        it('should return config with default, global, and test-specific settings', () => {
-            expect.hasAssertions();
-            checkConfigAgainstSnapshot(globalAndTestSpecificSettingsConfigFileName, 'urls');
-        });
-
-        it('should return config with all url types properly parsed', () => {
-            expect.assertions(6); // eslint-disable-line no-magic-numbers
-            const processedConfig = config(urlTypesConfigFileName);
-            // Case 1: Local file that exists.  Use regex since path change in different environments.
-            expect(processedConfig.urls[0].url).toMatch(/file:\/\/\/.*\/tests\/test-cases\/consoleLog.html/);
-            // Case 2: Local file that does not exist, so assume URL (add https://)
-            expect(processedConfig.urls[1].url).toStrictEqual('https://tests/test-cases/bar.html');
-            // Case 3: URL with no protocol (add https://)
-            expect(processedConfig.urls[2].url).toStrictEqual('https://localhost/foo.html'); // eslint-disable-line no-magic-numbers
-            // Case 4: URL with port and no protocol (add https://)
-            expect(processedConfig.urls[3].url).toStrictEqual('https://localhost:3000/foo.html'); // eslint-disable-line no-magic-numbers
-            // Case 5: URL with http protocol (unchanged)
-            expect(processedConfig.urls[4].url).toStrictEqual('http://localhost/foo.html'); // eslint-disable-line no-magic-numbers
-            // Case 6: URL with https protocol (unchanged)
-            expect(processedConfig.urls[5].url).toStrictEqual('https://localhost/foo.html'); // eslint-disable-line no-magic-numbers
-        });
-
-        it('should return the same config with test shorthand and property declaration', () => {
-            expect.assertions(1);
-            const shorthandConfig = config(allShorthandConfigFileName);
-            const testPropsConfig = config(allTestPropsConfigFileName);
-            expect(shorthandConfig).toStrictEqual(testPropsConfig);
-        });
-
-        it('should normalize ignored links in brokenLinkTest settings', () => {
-            expect.assertions(2); // eslint-disable-line no-magic-numbers
-            // Original link: https://this.url.is.ignored/
-            const normalizedLinks = ['https://this.url.is.ignored'];
-            const globalSettingUrl = 0; // URL inherits global settings
-            const testSettingUrl = 1; // URL has test-specific settings
-            const normalizedLinksConfig = config(ignoredLinksDenormalizedConfigFileName);
-            expect(normalizedLinksConfig.urls[globalSettingUrl].settings.brokenLinkTest.ignoredLinks).toStrictEqual(normalizedLinks);
-            expect(normalizedLinksConfig.urls[testSettingUrl].settings.brokenLinkTest.ignoredLinks).toStrictEqual(normalizedLinks);
-        });
-    });
-
-    // eslint-disable-next-line max-lines-per-function
-    describe('htmlhint settings', () => {
-        const defaultHtmlHintConfigFilename = './.htmlhintrc';
-        const invalidHtmlHintConfigFilename = './nonexistent/.htmlhintrc';
-
-        beforeEach(() => {
-            jest.restoreAllMocks();
-        });
-
-        it('should check for default htmlhintrc file if none specified in config', () => {
-            expect.assertions(1);
-            const fsExistsSpy = jest.spyOn(fs, 'existsSync').mockImplementation(() => false);
-            config(globalAndTestSpecificSettingsConfigFileName);
-            expect(fsExistsSpy).toHaveBeenCalledWith(defaultHtmlHintConfigFilename);
-        });
-
-        it('should check for htmlhintrc file from config if specified', () => {
-            expect.assertions(1);
-            const fsExistsSpy = jest.spyOn(fs, 'existsSync').mockImplementation(() => false);
-            config(htmlhintrcInvalidConfigFileName);
-            expect(fsExistsSpy).toHaveBeenCalledWith(invalidHtmlHintConfigFilename);
-        });
-
-        it('should return valid htmlhint settings from file specified in config if file exists', () => {
-            expect.hasAssertions();
-            checkConfigAgainstSnapshot(htmlhintrcValidConfigFileName, 'htmlHintConfig');
-        });
-
-        it('should return valid default htmlhint settings if .htmlhintrc file exists and none specified in config', () => {
-            expect.hasAssertions();
-            checkConfigAgainstSnapshot(globalAndTestSpecificSettingsConfigFileName, 'htmlHintConfig');
-        });
-
-        it('should return no htmlhint config if htmlhintrc file does not exist', () => {
-            expect.assertions(1);
-            const result = config(htmlhintrcInvalidConfigFileName);
-            expect(result.htmlHintConfig).toBeUndefined();
-        });
-    });
-
-    describe('reporter settings', () => {
-        it('should return default reporters if none specified in config', () => {
-            expect.assertions(1);
-            const processedConfig = config(globalTestSettingsConfigFileName);
-            expect(processedConfig).toStrictEqual(expect.objectContaining({ reporters: defaultConfig.reporters }));
-        });
-
-        it('should return reporters from config if valid', () => {
-            expect.assertions(1);
-            const expectedReporters = ['cli', 'html'];
-            const processedConfig = config(reportersValidConfigFileName);
-            expect(processedConfig).toStrictEqual(expect.objectContaining({ reporters: expectedReporters }));
-        });
-    });
-});
-
-// eslint-disable-next-line max-lines-per-function
-describe('lint config', () => {
-    it('should throw if config file not found', () => {
-        expect.assertions(1);
-        expect(() => config.lintConfigFile(nonExistentConfigFileName)).toThrow('ENOENT');
-    });
-
-    it('should throw if config file is not JSON', () => {
-        expect.assertions(1);
-        expect(() => config.lintConfigFile(invalidConfigFileName)).toThrow('Unexpected end of JSON input');
-    });
-
-    it('should return an object with a boolean isValid property', () => {
-        expect.assertions(1);
-        const results = config.lintConfigFile(cliDefaultConfigFileName);
-        expect(results).toStrictEqual(expect.objectContaining({ isValid: expect.any(Boolean) }));
-    });
-
-    it('should return an object with an errors array', () => {
-        expect.assertions(1);
-        const results = config.lintConfigFile(cliDefaultConfigFileName);
-        expect(results).toStrictEqual(expect.objectContaining({ errors: expect.any(Array) }));
-    });
-
-    it('should return an object with isValid true if schema is valid', () => {
-        expect.assertions(1);
-        const results = config.lintConfigFile(cliDefaultConfigFileName);
-        expect(results.isValid).toStrictEqual(true);
-    });
-
-    it('should return an object with isValid false if schema is invalid', () => {
-        expect.assertions(1);
-        const results = config.lintConfigFile(emptyUrlsConfigFileName);
-        expect(results.isValid).toStrictEqual(false);
-    });
-
-    it('should return an object with errors array populated if schema is invalid', () => {
-        expect.assertions(1);
-        const results = config.lintConfigFile(emptyUrlsConfigFileName);
-        expect(results.errors).toMatchSnapshot();
-    });
-});

package/tests/externalFileUtils.test.js

@@ -1,184 +0,0 @@
-'use strict';
-
-const fs = require('fs');
-const path = require('path');
-
-const axios = require('axios');
-
-const { shouldSaveFile, saveExternalScript } = require('../lib/externalFileUtils');
-
-// eslint-disable-next-line max-lines-per-function
-describe('shouldSaveFile', () => {
-    const urlBaseWithHost = 'https://foo.com/';
-    const urlBaseWithoutHost = 'file:///E:/this/is/a/test/';
-    const scriptFileName = 'jquery-3.5.1.min.js';
-    const pageFileName = 'index.html';
-    const invalidUrl = 'foo';
-
-    afterEach(() => {
-        jest.restoreAllMocks();
-    });
-
-    it('should return false for script and page with same host', () => {
-        expect.assertions(1);
-        const script = `${urlBaseWithHost}${scriptFileName}`;
-        const page = urlBaseWithHost;
-        expect(shouldSaveFile(script, page)).toStrictEqual(false);
-    });
-
-    it('should return false for script and page with same host and different protocols', () => {
-        expect.assertions(1);
-        const script = `${urlBaseWithHost}${scriptFileName}`;
-        const page = 'file://foo.com/';
-        expect(shouldSaveFile(script, page)).toStrictEqual(false);
-    });
-
-    it('should return true for script and page with different hosts', () => {
-        expect.assertions(1);
-        const script = `${urlBaseWithHost}${scriptFileName}`;
-        const page = `https://bar.com/${pageFileName}`;
-        expect(shouldSaveFile(script, page)).toStrictEqual(true);
-    });
-
-    it('should return true for script with no host and page with host', () => {
-        expect.assertions(1);
-        const script = `${urlBaseWithoutHost}${scriptFileName}`;
-        const page = urlBaseWithHost;
-        expect(shouldSaveFile(script, page)).toStrictEqual(true);
-    });
-
-    it('should return true for script with host and page with no host', () => {
-        expect.assertions(1);
-        const script = `${urlBaseWithHost}${scriptFileName}`;
-        const page = `${urlBaseWithoutHost}${pageFileName}`;
-        expect(shouldSaveFile(script, page)).toStrictEqual(true);
-    });
-
-    it('should return false for script and page with no host', () => {
-        expect.assertions(1);
-        const script = `${urlBaseWithoutHost}${scriptFileName}`;
-        const page = `${urlBaseWithoutHost}${pageFileName}`;
-        expect(shouldSaveFile(script, page)).toStrictEqual(false);
-    });
-
-    it('should throw for invalid script URL', () => {
-        expect.assertions(1);
-        const script = invalidUrl;
-        const page = urlBaseWithHost;
-        expect(() => shouldSaveFile(script, page)).toThrow('Invalid URL');
-    });
-
-    it('should throw for invalid page URL', () => {
-        expect.assertions(1);
-        const script = `${urlBaseWithoutHost}${scriptFileName}`;
-        const page = invalidUrl;
-        expect(() => shouldSaveFile(script, page)).toThrow('Invalid URL');
-    });
-});
-
-// eslint-disable-next-line max-lines-per-function
-describe('saveExternalScript', () => {
-    const jqueryUrl = 'https://code.jquery.com/jquery-3.5.1.slim.min.js';
-    const jqueryPath = path.join('pagean-external-scripts', 'code.jquery.com', 'jquery-3.5.1.slim.min.js');
-    const scriptText = 'this is a script';
-    const httpResponseOk = 200;
-    const httpResponseNotFound = 404;
-
-    afterEach(() => {
-        jest.restoreAllMocks();
-    });
-
-    const saveExternalScriptWithSpies = async(url, status = httpResponseOk, data = scriptText, fileExists = false) => {
-        const axiosSpy = jest.spyOn(axios, 'get').mockImplementation(() => {
-            if (status === httpResponseOk) {
-                return { status, data };
-            }
-            throw new Error(`Request failed with status code ${status}`);
-        });
-        const existsSpy = jest.spyOn(fs, 'existsSync').mockImplementation(() => fileExists);
-        const mkdirSpy = jest.spyOn(fs, 'mkdirSync').mockImplementation(() => {});
-        const writeFileSpy = jest.spyOn(fs, 'writeFileSync').mockImplementation(() => {});
-        const result = await saveExternalScript(url);
-        return {
-            result,
-            axiosSpy,
-            existsSpy,
-            mkdirSpy,
-            writeFileSpy
-        };
-    };
-
-    it('should try to get script if file does not exist', async() => {
-        expect.assertions(1);
-        const { axiosSpy } = await saveExternalScriptWithSpies(jqueryUrl);
-        expect(axiosSpy).toHaveBeenCalledWith(jqueryUrl);
-    });
-
-    it('should not try to get script, or make dir, or save file if file exists', async() => {
-        expect.assertions(3); // eslint-disable-line no-magic-numbers
-        const { axiosSpy, mkdirSpy, writeFileSpy } = await saveExternalScriptWithSpies(jqueryUrl, httpResponseOk, scriptText, true);
-        expect(axiosSpy).not.toHaveBeenCalled();
-        expect(mkdirSpy).not.toHaveBeenCalled();
-        expect(writeFileSpy).not.toHaveBeenCalled();
-    });
-
-    it('should create output directory if script is retrieved successfully', async() => {
-        expect.assertions(1);
-        const { mkdirSpy } = await saveExternalScriptWithSpies(jqueryUrl);
-        expect(mkdirSpy).toHaveBeenCalledWith(path.dirname(jqueryPath), expect.objectContaining({ recursive: true }));
-    });
-
-    it('should save file if script is retrieved successfully', async() => {
-        expect.assertions(1);
-        const { writeFileSpy } = await saveExternalScriptWithSpies(jqueryUrl, httpResponseOk, scriptText);
-        expect(writeFileSpy).toHaveBeenCalledWith(jqueryPath, scriptText);
-    });
-
-    it('should return script URL and saved file name if script is retrieved successfully', async() => {
-        expect.assertions(1);
-        const { result } = await saveExternalScriptWithSpies(jqueryUrl, httpResponseOk, scriptText);
-        expect(result).toStrictEqual(expect.objectContaining({
-            url: jqueryUrl,
-            localFile: jqueryPath
-        }));
-    });
-
-    it('should return script URL and saved file name if script already existed', async() => {
-        expect.assertions(1);
-        const { result } = await saveExternalScriptWithSpies(jqueryUrl, httpResponseOk, scriptText, true);
-        expect(result).toStrictEqual(expect.objectContaining({
-            url: jqueryUrl,
-            localFile: jqueryPath
-        }));
-    });
-
-    it('should not create output directory if script is not retrieved successfully', async() => {
-        expect.assertions(1);
-        const { mkdirSpy } = await saveExternalScriptWithSpies(jqueryUrl, httpResponseNotFound);
-        expect(mkdirSpy).not.toHaveBeenCalledWith();
-    });
-
-    it('should not save file if script is not retrieved successfully', async() => {
-        expect.assertions(1);
-        const { writeFileSpy } = await saveExternalScriptWithSpies(jqueryUrl, httpResponseNotFound);
-        expect(writeFileSpy).not.toHaveBeenCalledWith();
-    });
-
-    it('should return script URL and error message if script is is retrieved successfully', async() => {
-        expect.assertions(1);
-        const { result } = await saveExternalScriptWithSpies(jqueryUrl, httpResponseNotFound, scriptText);
-        expect(result).toStrictEqual(expect.objectContaining({
-            url: jqueryUrl,
-            error: expect.stringContaining(String(httpResponseNotFound))
-        }));
-    });
-
-    it('should retrieve script that matches snapshot', async() => {
-        expect.assertions(1);
-        // Add fs spies to avoid actually writing the file
-        jest.spyOn(fs, 'mkdirSync').mockImplementation(() => {});
-        const writeFileSpy = jest.spyOn(fs, 'writeFileSync').mockImplementation(() => {});
-        await saveExternalScript(jqueryUrl);
-        expect(writeFileSpy.mock.calls[0][1]).toMatchSnapshot();
-    });
-});

package/tests/index.test.js

@@ -1,181 +0,0 @@
-'use strict';
-
-const pagean = require('../index');
-const configParser = require('../lib/config');
-const reporter = require('../lib/reporter');
-const { testResultStates } = require('../lib/testUtils');
-const fileUtils = require('../lib/externalFileUtils');
-const linkUtils = require('../lib/linkUtils');
-
-// eslint-disable-next-line max-lines-per-function
-describe('integration tests', () => {
-    const allPassConfigFileName = './tests/test-configs/integration-tests/all-passing-tests.pageanrc.json';
-    const horizontalScrollbarTestFailConfigFileName = './tests/test-configs/integration-tests/horizontal-scrollbar.pageanrc.json';
-    const consoleOutputTestFailConfigFileName = './tests/test-configs/integration-tests/console-output.pageanrc.json';
-    const consoleErrorTestFailConfigFileName = './tests/test-configs/integration-tests/console-error.pageanrc.json';
-    const consoleErrorTestFailReporterHtmlConfigFileName = './tests/test-configs/integration-tests/console-error-reporter-html.pageanrc.json';
-    const consoleErrorTestFailReporterCliJsonConfigFileName = './tests/test-configs/integration-tests/console-error-reporter-cli-json.pageanrc.json';
-    const renderedHtmlTestFailConfigFileName = './tests/test-configs/integration-tests/html-error.pageanrc.json';
-    const pageLoadTimeTestFailConfigFileName = './tests/test-configs/integration-tests/page-load-time.pageanrc.json';
-    const externalScriptTestFailConfigFileName = './tests/test-configs/integration-tests/external-scripts-error.pageanrc.json';
-    const brokenLinksTestFailConfigFileName = './tests/test-configs/integration-tests/broken-links-error.pageanrc.json';
-
-    const horizontalScrollbarTestName = 'should not have a horizontal scrollbar';
-    const consoleOutputTestName = 'should not have console output';
-    const consoleErrorTestName = 'should not have console errors';
-    const renderedHtmlTestName = 'should have valid rendered HTML';
-    const pageLoadTimeTestName = 'should load page within 2 sec';
-    const externalScriptTestName = 'should not have external scripts';
-    const brokenLinksTestName = 'should not have broken links';
-
-    const executeTests = async(configFileName) => {
-        const config = configParser(configFileName);
-
-        const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation(() => { });
-        const processSpy = jest.spyOn(process, 'exit').mockImplementation(() => { });
-        const reporterSpy = jest.spyOn(reporter, 'saveReports').mockImplementation(() => { });
-        const saveScriptSpy = jest.spyOn(fileUtils, 'saveExternalScript').mockImplementation(() => { });
-        const checkLinkSpy = jest.spyOn(linkUtils, 'checkLink');
-
-        await pagean.executeAllTests(config);
-        return {
-            consoleLogSpy,
-            processSpy,
-            reporterSpy,
-            saveScriptSpy,
-            checkLinkSpy
-        };
-    };
-
-    const executeFailedIntegrationTest = async(config, testName) => {
-        expect.assertions(6); // eslint-disable-line no-magic-numbers
-        const { processSpy, reporterSpy } = await executeTests(config);
-
-        // Expect test suite to fail and exit with code 1
-        expect(processSpy).toHaveBeenCalledWith(1);
-        expect(reporterSpy).toHaveBeenCalledTimes(1);
-
-        const testResults = reporterSpy.mock.calls[0][0]; // eslint-disable-line prefer-destructuring -- less intuitive
-        // Expect only one URL to be tested
-        expect(testResults.results).toHaveLength(1);
-        const failedTests = testResults.results[0].tests;
-        // Expect only one test to be run
-        expect(failedTests).toHaveLength(1);
-        const failedTest = failedTests[0]; // eslint-disable-line prefer-destructuring -- less intuitive
-        // Verify the correct test was run and failed
-        expect(failedTest.name).toStrictEqual(testName);
-        expect(failedTest.result).toStrictEqual(testResultStates.failed);
-    };
-
-    afterEach(() => {
-        jest.restoreAllMocks();
-    });
-
-    it('should execute all tests and all should pass', async() => {
-        expect.assertions(3); // eslint-disable-line no-magic-numbers
-        const { processSpy, reporterSpy, saveScriptSpy } = await executeTests(allPassConfigFileName);
-        // This passes when npm test is called, but fails in other cases like watch
-        // expect(processSpy).not.toHaveBeenCalled();
-        expect(processSpy).not.toHaveBeenCalled();
-        expect(reporterSpy).toHaveBeenCalledTimes(1);
-        expect(saveScriptSpy).not.toHaveBeenCalled();
-    });
-
-    it('should execute tests and horizontal scrollbar test should fail', async() => {
-        expect.hasAssertions();
-        await executeFailedIntegrationTest(horizontalScrollbarTestFailConfigFileName, horizontalScrollbarTestName);
-    });
-
-    it('should execute tests and console output test should fail', async() => {
-        expect.hasAssertions();
-        await executeFailedIntegrationTest(consoleOutputTestFailConfigFileName, consoleOutputTestName);
-    });
-
-    it('should execute tests and console error test should fail', async() => {
-        expect.hasAssertions();
-        await executeFailedIntegrationTest(consoleErrorTestFailConfigFileName, consoleErrorTestName);
-    });
-
-    it('should execute tests and rendered HTML test should fail', async() => {
-        expect.hasAssertions();
-        await executeFailedIntegrationTest(renderedHtmlTestFailConfigFileName, renderedHtmlTestName);
-    });
-
-    it('should execute tests and page load time test should fail', async() => {
-        expect.hasAssertions();
-        await executeFailedIntegrationTest(pageLoadTimeTestFailConfigFileName, pageLoadTimeTestName);
-    });
-
-    it('should execute tests and external script test should fail', async() => {
-        expect.hasAssertions();
-        await executeFailedIntegrationTest(externalScriptTestFailConfigFileName, externalScriptTestName);
-    });
-
-    it('should execute tests and broken links test should fail', async() => {
-        expect.hasAssertions();
-        await executeFailedIntegrationTest(brokenLinksTestFailConfigFileName, brokenLinksTestName);
-    });
-
-    // eslint-disable-next-line max-lines-per-function
-    it('should execute all tests and report failure with the correct tests failed', async() => {
-        expect.assertions(7); // eslint-disable-line no-magic-numbers
-        const configFileName = './.pageanrc.json';
-        const totalTests = 51;
-        const externalScriptCount = 4;
-        const linkCount = 7;
-
-        const { processSpy, reporterSpy, saveScriptSpy, checkLinkSpy } = await executeTests(configFileName);
-
-        expect(processSpy).toHaveBeenCalledWith(1);
-        expect(reporterSpy).toHaveBeenCalledTimes(1);
-        expect(saveScriptSpy).toHaveBeenCalledTimes(externalScriptCount);
-        expect(checkLinkSpy).toHaveBeenCalledTimes(linkCount);
-
-        // eslint-disable-next-line prefer-destructuring -- less intuitive
-        const testResults = reporterSpy.mock.calls[0][0];
-        // Verify number of expected tests were run
-        expect(testResults.summary.tests).toStrictEqual(totalTests);
-        // Verify appropriate tests failed.  Some tests have log data with times and paths that
-        // will fail if just checking snapshot of results, so filter down to URL and failed tests.
-        const failedTests = testResults.results.reduce((accumulator, currentTestUrl) => {
-            const failed = currentTestUrl.tests
-                .filter(test => test.result === testResultStates.failed)
-                .map(test => ({ url: currentTestUrl.url, name: test.name }));
-            accumulator.push(...failed);
-            return accumulator;
-        }, []);
-        expect(failedTests).toMatchSnapshot();
-
-        // Check that console message field names are correct and returning data from puppeteer.
-        // These contain environment-specific data, so exact test isn't checked, but the fields
-        // will be empty if they are no longer reported by Chromium (see #85, #86).
-        // eslint-disable-next-line prefer-destructuring
-        const consoleLogTestFailResult = testResults.results[0].tests[1];
-        expect(consoleLogTestFailResult.data[0]).toStrictEqual(expect.objectContaining({
-            _type: expect.any(String),
-            _text: expect.any(String),
-            _stackTraceLocations: expect.any(Array)
-        }));
-    });
-
-    it('should pass reporter config when saving reports', async() => {
-        expect.assertions(1);
-        const { reporterSpy } = await executeTests(consoleErrorTestFailReporterCliJsonConfigFileName);
-        expect(reporterSpy.mock.calls[0][1]).toStrictEqual(['cli', 'json']);
-    });
-
-    it('should write all results to console if CLI reporter enabled', async() => {
-        expect.assertions(1);
-        const { consoleLogSpy } = await executeTests(consoleErrorTestFailReporterCliJsonConfigFileName);
-        // Console should be called 3 times: url, test result, and final results
-        // eslint-disable-next-line no-magic-numbers
-        expect(consoleLogSpy).toHaveBeenCalledTimes(3);
-    });
-
-    it('should only summary results to console if CLI reporter disabled', async() => {
-        expect.assertions(1);
-        const { consoleLogSpy } = await executeTests(consoleErrorTestFailReporterHtmlConfigFileName);
-        // Console should only be called once for final results
-        expect(consoleLogSpy).toHaveBeenCalledTimes(1);
-    });
-});