pagean 4.4.2 → 6.0.1

package/tests/linkUtils.test.js

@@ -1,290 +0,0 @@
-'use strict';
-
-const axios = require('axios');
-const puppeteer = require('puppeteer');
-const protocolify = require('protocolify');
-
-const { checkLink, httpResponse, isFailedResponse, normalizeLink } = require('../lib/linkUtils');
-
-// eslint-disable-next-line max-lines-per-function
-describe('check link', () => {
-    const testUrl = './tests/test-cases/brokenLinks.html';
-    const testUrlLink = protocolify(testUrl);
-    const userAgent = 'pagean test user-agent';
-    const puppeteerLaunchOptions = { args: ['--no-sandbox'] };
-    let browser, page;
-
-    const getContext = (ignoredLinks = []) => {
-        return {
-            testSettings: {
-                ignoredLinks
-            },
-            page
-        };
-    };
-
-    beforeAll(async() => {
-        browser = await puppeteer.launch(puppeteerLaunchOptions);
-        page = await browser.newPage();
-        page.setUserAgent(userAgent);
-        await page.goto(testUrlLink, { waitUntil: 'load' });
-    });
-
-    afterEach(() => {
-        jest.restoreAllMocks();
-    });
-
-    afterAll(async() => {
-        await page.close();
-        await browser.close();
-    });
-
-    // eslint-disable-next-line max-lines-per-function
-    const checkLinksWithMocks = async(link, ignoredLinks, invalidPage = false, httpStatus = httpResponse.ok) => {
-        const context = getContext(ignoredLinks);
-        if (invalidPage) {
-            // This enables forcing an error to be thrown for various test cases
-            delete context.page;
-        }
-        const pageGetElementSpy = jest.spyOn(page, '$');
-        const pageEvaluateSpy = jest.spyOn(page, 'evaluate');
-
-        const axiosMock = () => {
-            if (isNaN(httpStatus)) {
-                // If execution error, format to match axios error
-                const err = new Error();
-                err.code = httpStatus;
-                throw err;
-            }
-            else if (httpStatus >= httpResponse.badRequest) {
-                // If erroneous response, throw error with response to match axios
-                const err = new Error();
-                err.response = { status: httpStatus };
-                throw err;
-            }
-            return { status: httpStatus };
-        };
-        const axiosHeadSpy = jest.spyOn(axios, 'head').mockImplementation(axiosMock);
-        const axiosGetSpy = jest.spyOn(axios, 'get').mockImplementation(axiosMock);
-
-        const result = await checkLink(context, link);
-
-        return {
-            axiosGetSpy,
-            axiosHeadSpy,
-            pageEvaluateSpy,
-            pageGetElementSpy,
-            result
-        };
-    };
-
-    // eslint-disable-next-line max-lines-per-function
-    describe('ignored links', () => {
-        const ignoreLinksTestLink = 'https://this.is.a.test/';
-        const normalizedIgnoreLinksTestLink = 'https://this.is.a.test';
-
-        it('should return 100 if exact link is in ignored links', async() => {
-            expect.assertions(1);
-            const ignoredLinks = [normalizedIgnoreLinksTestLink];
-            const testResults = await checkLinksWithMocks(ignoreLinksTestLink, ignoredLinks);
-            expect(testResults.result).toStrictEqual(httpResponse.continue);
-        });
-
-        it('should return 100 if normalized link is in ignored links', async() => {
-            expect.assertions(1);
-            const ignoredLinks = [normalizedIgnoreLinksTestLink];
-            const testResults = await checkLinksWithMocks(normalizedIgnoreLinksTestLink, ignoredLinks);
-            expect(testResults.result).toStrictEqual(httpResponse.continue);
-        });
-
-        it('should not return 100 is link is not in ignored links', async() => {
-            expect.assertions(1);
-            const ignoredLinks = ['https://this.is.not.a.test/'];
-            const testResults = await checkLinksWithMocks(ignoreLinksTestLink, ignoredLinks);
-            expect(testResults.result).not.toStrictEqual(httpResponse.continue);
-        });
-
-        it('should not return 100 is ignored links are not specified', async() => {
-            expect.assertions(1);
-            const testResults = await checkLinksWithMocks(ignoreLinksTestLink);
-            expect(testResults.result).not.toStrictEqual(httpResponse.continue);
-        });
-    });
-
-    // eslint-disable-next-line max-lines-per-function
-    describe('same page links', () => {
-        it('should return 200 for url with # and no element (top of page)', async() => {
-            expect.assertions(1);
-            const link = `${testUrlLink}#`;
-            const testResults = await checkLinksWithMocks(link);
-            expect(testResults.result).toStrictEqual(httpResponse.ok);
-        });
-
-        it('should return 200 for url with #top', async() => {
-            expect.assertions(1);
-            const link = `${testUrlLink}#top`;
-            const testResults = await checkLinksWithMocks(link);
-            expect(testResults.result).toStrictEqual(httpResponse.ok);
-        });
-
-        it('should check page for element if element specified', async() => {
-            expect.assertions(1);
-            const element = '#foo';
-            const link = `${testUrlLink}${element}`;
-            const testResults = await checkLinksWithMocks(link);
-            expect(testResults.pageGetElementSpy).toHaveBeenCalledWith(element);
-        });
-
-        it('should return 200 if element found on page', async() => {
-            expect.assertions(1);
-            const element = '#linked';
-            const link = `${testUrlLink}${element}`;
-            const testResults = await checkLinksWithMocks(link);
-            expect(testResults.result).toStrictEqual(httpResponse.ok);
-        });
-
-        it('should return #element not found error if element is not found on page', async() => {
-            expect.assertions(1);
-            const element = '#notlinked';
-            const link = `${testUrlLink}${element}`;
-            const testResults = await checkLinksWithMocks(link);
-            expect(testResults.result).toStrictEqual(`${element} Not Found`);
-        });
-
-        it('should return 999 if error thrown while checking link', async() => {
-            expect.assertions(1);
-            const element = '#linked';
-            const link = `${testUrlLink}${element}`;
-            const testResults = await checkLinksWithMocks(link, [], true);
-            expect(testResults.result).toStrictEqual(httpResponse.unknownError);
-        });
-    });
-
-    // eslint-disable-next-line max-lines-per-function
-    describe('external page links', () => {
-        const externalLink = 'https://www.google.com';
-
-        it('should make only a HEAD request for link if not same page and response is valid', async() => {
-            expect.assertions(2); // eslint-disable-line no-magic-numbers
-            const testResults = await checkLinksWithMocks(externalLink);
-            expect(testResults.axiosHeadSpy.mock.calls[0][0]).toStrictEqual(externalLink);
-            expect(testResults.axiosGetSpy).not.toHaveBeenCalled();
-        });
-
-        it('should make only a HEAD request for link if not same page and HEAD returns code 429', async() => {
-            expect.assertions(2); // eslint-disable-line no-magic-numbers
-            const testResults = await checkLinksWithMocks(externalLink, [], false, httpResponse.tooManyRequests);
-            expect(testResults.axiosHeadSpy.mock.calls[0][0]).toStrictEqual(externalLink);
-            expect(testResults.axiosGetSpy).not.toHaveBeenCalled();
-        });
-
-        it('should make only a HEAD request for link if not same page and HEAD returns an execution error', async() => {
-            expect.assertions(2); // eslint-disable-line no-magic-numbers
-            const responseCode = 'ENOTFOUND';
-            const testResults = await checkLinksWithMocks(externalLink, [], false, responseCode);
-            expect(testResults.axiosHeadSpy.mock.calls[0][0]).toStrictEqual(externalLink);
-            expect(testResults.axiosGetSpy).not.toHaveBeenCalled();
-        });
-
-        it('should make only a HEAD request passing the current page user agent if response is valid', async() => {
-            expect.assertions(2); // eslint-disable-line no-magic-numbers
-            const expectedHeaders = { headers: { 'User-Agent': userAgent } };
-            const testResults = await checkLinksWithMocks(externalLink);
-            expect(testResults.axiosHeadSpy.mock.calls[0][1]).toStrictEqual(expect.objectContaining(expectedHeaders));
-            expect(testResults.axiosGetSpy).not.toHaveBeenCalled();
-        });
-
-        it('should make HEAD and GET request for link if not same page and HEAD returns error', async() => {
-            expect.assertions(2); // eslint-disable-line no-magic-numbers
-            const testResults = await checkLinksWithMocks(externalLink, [], false, httpResponse.badRequest);
-            expect(testResults.axiosHeadSpy.mock.calls[0][0]).toStrictEqual(externalLink);
-            expect(testResults.axiosGetSpy.mock.calls[0][0]).toStrictEqual(externalLink);
-        });
-
-        it('should make HEAD and GET request passing the current page user agent if HEAD returns error', async() => {
-            expect.assertions(2); // eslint-disable-line no-magic-numbers
-            const expectedHeaders = { headers: { 'User-Agent': userAgent } };
-            const testResults = await checkLinksWithMocks(externalLink, [], false, httpResponse.badRequest);
-            expect(testResults.axiosHeadSpy.mock.calls[0][1]).toStrictEqual(expect.objectContaining(expectedHeaders));
-            expect(testResults.axiosGetSpy.mock.calls[0][1]).toStrictEqual(expect.objectContaining(expectedHeaders));
-        });
-
-        it('should return the HTTP response status for a nominal request', async() => {
-            expect.assertions(1);
-            const testResults = await checkLinksWithMocks(externalLink, [], false, httpResponse.ok);
-            expect(testResults.result).toStrictEqual(httpResponse.ok);
-        });
-
-        it('should return the HTTP response status for an off-nominal request with a response', async() => {
-            expect.assertions(1);
-            const link = 'https://www.google.com/this.is.not.found/';
-            const testResults = await checkLinksWithMocks(link, [], false, httpResponse.notFound);
-            expect(testResults.result).toStrictEqual(httpResponse.notFound);
-        });
-
-        it('should return the error code for a request with an execution error', async() => {
-            expect.assertions(1);
-            const link = 'https://this.is.a.test/';
-            const responseCode = 'ENOTFOUND';
-            const testResults = await checkLinksWithMocks(link, [], false, responseCode);
-            expect(testResults.result).toStrictEqual(responseCode);
-        });
-    });
-});
-
-describe('is failed response', () => {
-    const response = { status: undefined };
-    it('should return true for any numeric status value greater than or equal to 400', () => {
-        // eslint-disable-next-line no-magic-numbers
-        expect.assertions(2);
-        response.status = 400;
-        expect(isFailedResponse(response)).toStrictEqual(true);
-        response.status = 500;
-        expect(isFailedResponse(response)).toStrictEqual(true);
-    });
-
-    it('return false for any numeric status value less than 400', () => {
-        // eslint-disable-next-line no-magic-numbers
-        expect.assertions(2);
-        response.status = 302;
-        expect(isFailedResponse(response)).toStrictEqual(false);
-        response.status = 200;
-        expect(isFailedResponse(response)).toStrictEqual(false);
-    });
-
-    it('return true for any status value that is nor a number', () => {
-        // eslint-disable-next-line no-magic-numbers
-        expect.assertions(2);
-        response.status = 'ENOTFOUND';
-        expect(isFailedResponse(response)).toStrictEqual(true);
-        response.status = undefined;
-        expect(isFailedResponse(response)).toStrictEqual(true);
-    });
-});
-
-describe('normalize link', () => {
-    const referenceUrl = 'https://www.test.com';
-
-    it('should remove trailing slash without altering URL', () => {
-        expect.assertions(1);
-        const initialURL = `${referenceUrl}/`;
-        expect(normalizeLink(initialURL)).toStrictEqual(referenceUrl);
-    });
-
-    it('should not strip www from domain', () => {
-        expect.assertions(1);
-        expect(normalizeLink(referenceUrl)).toStrictEqual(referenceUrl);
-    });
-
-    it('should add https as protocol if protocol relative URL', () => {
-        expect.assertions(1);
-        const initialURL = referenceUrl.replace('https:', '');
-        expect(normalizeLink(initialURL)).toStrictEqual(referenceUrl);
-    });
-
-    it('should not remove hash from url', () => {
-        expect.assertions(1);
-        const initialURL = `${referenceUrl}/#elementId`;
-        expect(normalizeLink(initialURL)).toStrictEqual(initialURL);
-    });
-});

package/tests/logger.test.js

@@ -1,324 +0,0 @@
-/* eslint-disable max-lines */
-
-'use strict';
-
-const testLogger = require('../lib/logger');
-const { testResultStates } = require('../lib/testUtils');
-const defaultConfig = require('../lib/default-config.json');
-defaultConfig.project = 'Default project';
-
-const configNoCli = {
-    reporters: [
-        'html',
-        'json'
-    ]
-};
-
-const defaultUrl = 'https://somewhere.com';
-const defaultTestName = 'should run a test';
-
-// eslint-disable-next-line max-lines-per-function
-describe('startUrlTests', () => {
-    let loggerWithCli, loggerNoCli;
-
-    beforeEach(() => {
-        loggerWithCli = testLogger(defaultConfig);
-        loggerNoCli = testLogger(configNoCli);
-    });
-
-    afterEach(() => {
-        jest.restoreAllMocks();
-    });
-
-    it('should add URL results object to test results', () => {
-        expect.assertions(3); // eslint-disable-line no-magic-numbers
-        // Console log is mocked to avoid writing output to the console during the test
-        jest.spyOn(console, 'log').mockImplementation(() => {});
-
-        const startingResults = loggerWithCli.getTestResults();
-        expect(startingResults.results).toHaveLength(0);
-
-        loggerWithCli.startUrlTests(defaultUrl);
-        const endingResults = loggerWithCli.getTestResults();
-        expect(endingResults.results).toHaveLength(1);
-        expect(endingResults.results[0].url).toStrictEqual(defaultUrl);
-    });
-
-    it('should log to console with URL being tested if CLI reporter enabled', () => {
-        expect.assertions(1);
-        const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
-        loggerWithCli.startUrlTests(defaultUrl);
-        expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining(defaultUrl));
-    });
-
-    it('should not log to console with URL being tested if CLI reporter disabled', () => {
-        expect.assertions(1);
-        const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
-        loggerNoCli.startUrlTests(defaultUrl);
-        expect(consoleLogSpy).not.toHaveBeenCalled();
-    });
-});
-
-// eslint-disable-next-line max-lines-per-function
-describe('logTestResults', () => {
-    let loggerWithCli, loggerNoCli;
-
-    beforeEach(() => {
-        loggerWithCli = testLogger(defaultConfig);
-        loggerNoCli = testLogger(configNoCli);
-    });
-
-    afterEach(() => {
-        jest.restoreAllMocks();
-        delete require.cache[require.resolve('../lib/logger')];
-    });
-
-    // This includes only the console log from startUrlTests and getTestResults
-    const consoleLoggerSpyDefaultCalls = 2;
-    const testLogTestResults = (testResults, logger) => {
-        const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
-
-        logger.startUrlTests(defaultUrl);
-        logger.logTestResults(testResults);
-
-        const allTestResults = logger.getTestResults();
-
-        return { allTestResults, consoleLogSpy };
-    };
-
-    const testResultSymbols = Object.freeze({
-        passed: '√',
-        failed: '×',
-        warning: '‼'
-    });
-
-    const testConsoleLogOutput = (testResult, logger) => {
-        const consoleSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
-
-        logger.startUrlTests(defaultUrl);
-
-        const testResults = {
-            name: defaultTestName,
-            result: testResult,
-            data: []
-        };
-        logger.logTestResults(testResults);
-        return consoleSpy;
-    };
-
-    it('should not log test results if no results provided', () => {
-        expect.assertions(2); // eslint-disable-line no-magic-numbers
-        const { allTestResults, consoleLogSpy } = testLogTestResults(undefined, loggerWithCli);
-        expect(allTestResults.results[0].tests).toHaveLength(0);
-        expect(consoleLogSpy).toHaveBeenCalledTimes(consoleLoggerSpyDefaultCalls);
-    });
-
-    it('should log test results if provided', () => {
-        expect.assertions(1);
-        const testResults = {
-            name: defaultTestName,
-            result: testResultStates.passed,
-            data: []
-        };
-        const { allTestResults } = testLogTestResults(testResults, loggerWithCli);
-        expect(allTestResults.results[0].tests[0]).toStrictEqual(testResults);
-    });
-
-    it('should output test name to console if test results provided and CLI reporter enabled', () => {
-        expect.assertions(1);
-        const consoleSpy = testConsoleLogOutput(testResultStates.passed, loggerWithCli);
-        // eslint-disable-next-line no-magic-numbers
-        expect(consoleSpy).toHaveBeenNthCalledWith(2, expect.stringContaining(defaultTestName));
-    });
-
-    it('should not output test name to console if test results provided and CLI reporter disabled', () => {
-        expect.assertions(1);
-        const consoleSpy = testConsoleLogOutput(testResultStates.passed, loggerNoCli);
-        expect(consoleSpy).not.toHaveBeenCalled();
-    });
-
-    const testConsoleLogTestResults = (testResult) => {
-        expect.assertions(2); // eslint-disable-line no-magic-numbers
-        const consoleSpy = testConsoleLogOutput(testResult, loggerWithCli);
-        /* eslint-disable no-magic-numbers */
-        expect(consoleSpy).toHaveBeenNthCalledWith(2, expect.stringContaining(testResult));
-        expect(consoleSpy).toHaveBeenNthCalledWith(2, expect.stringContaining(testResultSymbols[testResult]));
-        /* eslint-enable no-magic-numbers */
-    };
-
-    const testNoConsoleLogTestResults = (testResult) => {
-        expect.assertions(1);
-        const consoleSpy = testConsoleLogOutput(testResult, loggerNoCli);
-        expect(consoleSpy).not.toHaveBeenCalled();
-    };
-
-    it('should output test results to console for a passed test if CLI reporter enabled', () => {
-        expect.hasAssertions();
-        testConsoleLogTestResults(testResultStates.passed);
-    });
-
-    it('should not output test results to console for a passed test if CLI reporter disabled', () => {
-        expect.hasAssertions();
-        testNoConsoleLogTestResults(testResultStates.passed);
-    });
-
-    it('should output test results to console for a warning test if CLI reporter enabled', () => {
-        expect.hasAssertions();
-        testConsoleLogTestResults(testResultStates.warning);
-    });
-
-    it('should not output test results to console for a warning test if CLI reporter disabled', () => {
-        expect.hasAssertions();
-        testNoConsoleLogTestResults(testResultStates.warning);
-    });
-
-    it('should output test results to console for a failed test if CLI reporter enabled', () => {
-        expect.hasAssertions();
-        testConsoleLogTestResults(testResultStates.failed);
-    });
-
-    it('should not output test results to console for a failed test if CLI reporter disabled', () => {
-        expect.hasAssertions();
-        testNoConsoleLogTestResults(testResultStates.failed);
-    });
-
-    it('should increment only test and passed counters for a passed test', () => {
-        expect.assertions(4); // eslint-disable-line no-magic-numbers
-        const testResults = {
-            name: defaultTestName,
-            result: testResultStates.passed
-        };
-        const { allTestResults } = testLogTestResults(testResults, loggerWithCli);
-        expect(allTestResults.summary.tests).toStrictEqual(1);
-        expect(allTestResults.summary.passed).toStrictEqual(1);
-        expect(allTestResults.summary.warning).toStrictEqual(0);
-        expect(allTestResults.summary.failed).toStrictEqual(0);
-    });
-
-    it('should increment only test and failed counters for a failed test', () => {
-        expect.assertions(4); // eslint-disable-line no-magic-numbers
-        const testResults = {
-            name: defaultTestName,
-            result: testResultStates.failed
-        };
-        const { allTestResults } = testLogTestResults(testResults, loggerWithCli);
-        expect(allTestResults.summary.tests).toStrictEqual(1);
-        expect(allTestResults.summary.passed).toStrictEqual(0);
-        expect(allTestResults.summary.warning).toStrictEqual(0);
-        expect(allTestResults.summary.failed).toStrictEqual(1);
-    });
-
-    it('should increment only test and warning counters for a warning test', () => {
-        expect.assertions(4); // eslint-disable-line no-magic-numbers
-        const testResults = {
-            name: defaultTestName,
-            result: testResultStates.warning
-        };
-        const { allTestResults } = testLogTestResults(testResults, loggerWithCli);
-        expect(allTestResults.summary.tests).toStrictEqual(1);
-        expect(allTestResults.summary.passed).toStrictEqual(0);
-        expect(allTestResults.summary.warning).toStrictEqual(1);
-        expect(allTestResults.summary.failed).toStrictEqual(0);
-    });
-});
-
-// eslint-disable-next-line max-lines-per-function
-describe('getTestResults', () => {
-    let loggerWithCli, loggerNoCli;
-
-    beforeEach(() => {
-        loggerWithCli = testLogger(defaultConfig);
-        loggerNoCli = testLogger(configNoCli);
-    });
-
-    afterEach(() => {
-        jest.restoreAllMocks();
-    });
-
-    const testGetTestResults = (includeTests, testName, testResult, logger) => {
-        const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation(() => {});
-
-        if (includeTests) {
-            logger.startUrlTests(defaultUrl);
-            const name = testName;
-            const result = testResult;
-            logger.logTestResults({ name, result });
-        }
-
-        const results = logger.getTestResults();
-        return {
-            results,
-            consoleLogSpy
-        };
-    };
-
-    it('should return a results object with appropriate properties with no tests run', () => {
-        expect.assertions(2); // eslint-disable-line no-magic-numbers
-
-        const { results } = testGetTestResults(false, undefined, undefined, loggerWithCli);
-        expect(results).toStrictEqual(expect.objectContaining({
-            project: defaultConfig.project,
-            executionStart: expect.any(Date),
-            summary: {
-                tests: 0,
-                passed: 0,
-                warning: 0,
-                failed: 0
-            },
-            results: expect.any(Array)
-        }));
-        expect(results.results).toHaveLength(0);
-    });
-
-    it('should return a results object with appropriate properties with tests run', () => {
-        expect.assertions(3); // eslint-disable-line no-magic-numbers
-
-        const testName = defaultTestName;
-        const testResult = testResultStates.passed;
-        const { results } = testGetTestResults(true, testName, testResult, loggerWithCli);
-
-        expect(results).toStrictEqual(expect.objectContaining({
-            project: defaultConfig.project,
-            executionStart: expect.any(Date),
-            summary: {
-                tests: 1,
-                passed: 1,
-                warning: 0,
-                failed: 0
-            },
-            results: expect.any(Array)
-        }));
-        expect(results.results).toHaveLength(1);
-        expect(results.results[0]).toStrictEqual(expect.objectContaining({
-            url: defaultUrl,
-            tests: [{ name: testName, result: testResult }] }));
-    });
-
-    const testTestResultsSummary = (logger, messageCount) => {
-        expect.assertions(4); // eslint-disable-line no-magic-numbers
-
-        const testResult = testResultStates.warning;
-        const { consoleLogSpy } = testGetTestResults(true, defaultTestName, testResult, logger);
-
-        // eslint-disable-next-line prefer-destructuring
-        const message = consoleLogSpy.mock.calls[messageCount - 1][0];
-        expect(message).toMatch(/Tests: 1/);
-        expect(message).toMatch(/Passed: 0/);
-        expect(message).toMatch(/Warning: 1/);
-        expect(message).toMatch(/Failed: 0/);
-    };
-
-    it('should log to console the test result summary with total, passed, failed, and warning counts if CLI reporter enabled', () => {
-        expect.hasAssertions();
-        // Expect test name, test result, and the final results messages
-        const messageCount = 3;
-        testTestResultsSummary(loggerWithCli, messageCount);
-    });
-
-    it('should log to console the test result summary with total, passed, failed, and warning counts if CLI reporter disabled', () => {
-        expect.hasAssertions();
-        // Expect only the final results message
-        const messageCount = 1;
-        testTestResultsSummary(loggerNoCli, messageCount);
-    });
-});