@axe-core/cli 4.7.4-60abf5e.0 → 4.7.4-7f71bce.0

package/src/lib/axe-test-urls.test.ts

@@ -1,73 +0,0 @@
-import 'mocha';
-import { assert } from 'chai';
-import testPages from './axe-test-urls';
-import { ConfigParams } from '../types';
-
-describe('testPages', function () {
-  this.timeout(10000);
-  let config: ConfigParams;
-  let mockDriver: any;
-
-  beforeEach(() => {
-    const func = async (arg: any) => '{}';
-    mockDriver = {
-      get: func,
-      executeAsyncScript: func,
-      executeScript: func,
-      wait: func,
-      switchTo: () => ({ defaultContent: () => {} }),
-      findElements: async () => [],
-      quit: func,
-      manage: () => ({
-        setTimeouts: func
-      })
-    };
-    config = { driver: mockDriver };
-  });
-
-  it('return a promise', () => {
-    assert.instanceOf(testPages([], config), Promise);
-  });
-
-  it('calls driver.get() for each URL', async () => {
-    const urlsCalled: string[] = [];
-    const urls = ['http://foo', 'http://bar', 'http://baz'];
-
-    mockDriver.get = async (url: string) => {
-      urlsCalled.push(url);
-      return url;
-    };
-
-    await testPages(urls, config);
-
-    assert.deepEqual(urlsCalled, urls);
-  });
-
-  it('injects axe into the page', async () => {
-    const scripts: string[] = [];
-    config.axeSource = 'axe="hi, I am axe"';
-    mockDriver.executeScript = async (script: string) => {
-      scripts.push(script);
-      return script;
-    };
-
-    await testPages(['http://foo'], config);
-    assert.include(scripts[0].toString(), config.axeSource);
-  });
-
-  it('runs axe once the page is loaded', async () => {
-    const asyncScripts: string[] = [];
-    mockDriver.executeAsyncScript = async (script: string) => {
-      asyncScripts.push(script);
-      return '{}';
-    };
-
-    await testPages(['http://foo'], config);
-
-    assert.isDefined(
-      asyncScripts
-        .map(script => script.toString())
-        .find(script => script.match(/(axe\.run)|(axe\.a11yCheck)/))
-    );
-  });
-});

package/src/lib/axe-test-urls.ts

@@ -1,98 +0,0 @@
-import WebDriver from 'selenium-webdriver';
-import AxeBuilder from '@axe-core/webdriverjs';
-import { AxeResults } from 'axe-core';
-import { EventResponse, ConfigParams } from '../types';
-
-const testPages = async (
-  urls: string | string[],
-  config: ConfigParams,
-  events?: EventResponse
-): Promise<AxeResults[] | AxeResults> => {
-  const driver: WebDriver.WebDriver = await config.driver;
-
-  if (urls.length === 0) {
-    await driver.quit();
-    return Promise.resolve([]);
-  }
-
-  return new Promise((resolve, reject) => {
-    const currentUrl = urls[0].replace(/[,;]$/, '');
-
-    if (events?.onTestStart) {
-      events?.onTestStart(currentUrl);
-    }
-
-    if (config.timer) {
-      events?.startTimer('axe page load time');
-    }
-
-    driver
-      .get(currentUrl)
-      .then(() => {
-        if (config.timer) {
-          events?.endTimer('axe page load time');
-        }
-
-        if (config.loadDelay) {
-          events?.waitingMessage(config.loadDelay);
-        }
-
-        return new Promise(resolve => {
-          setTimeout(resolve, config.loadDelay);
-        });
-      })
-      .then(() => {
-        const axe = new AxeBuilder(driver, config.axeSource);
-
-        if (Array.isArray(config.include)) {
-          config.include.forEach((include: string) => axe.include(include));
-        }
-
-        if (Array.isArray(config.exclude)) {
-          config.exclude.forEach((exclude: string) => axe.exclude(exclude));
-        }
-
-        if (config.tags) {
-          axe.withTags(config.tags);
-        } else if (config.rules) {
-          axe.withRules(config.rules);
-        }
-
-        /* istanbul ignore if */
-        if (config.disable) {
-          axe.disableRules(config.disable);
-        }
-
-        if (config.timer) {
-          events?.startTimer('axe-core execution time');
-        }
-
-        axe.analyze((err: Error | null, results: AxeResults) => {
-          if (config.timer) {
-            events?.endTimer('axe-core execution time');
-          }
-
-          /* istanbul ignore if */
-          if (err) {
-            return reject(err);
-          }
-
-          // Notify about the update
-          if (events?.onTestComplete) {
-            events?.onTestComplete(results);
-          }
-
-          // Move to the next item
-          testPages(urls.slice(1), config, events).then((out: AxeResults) => {
-            resolve([results].concat(out));
-          });
-        });
-      })
-      .catch(async e => {
-        await driver.quit();
-        reject(e);
-      });
-  });
-};
-
-export default testPages;

package/src/lib/events.test.ts

@@ -1,26 +0,0 @@
-import 'mocha';
-import { assert } from 'chai';
-import events from './events';
-
-describe('events()', () => {
-  const event = events({
-    silentMode: false,
-    timer: false,
-    cliReporter: () => {},
-    verbose: false,
-    exit: false
-  });
-  const functions = [
-    'startTimer',
-    'endTimer',
-    'waitingMessage',
-    'onTestStart',
-    'onTestComplete'
-  ];
-  for (const eventFunction of functions) {
-    it(`${eventFunction} is a typeof function`, () => {
-      // @ts-ignore
-      assert.isFunction(event[eventFunction]);
-    });
-  }
-});

package/src/lib/events.ts

@@ -1,68 +0,0 @@
-import type { AxeResults } from 'axe-core';
-import type { EventParams } from '../types';
-import { selectorToString, error, link, bold, green } from './utils';
-
-export default ({ silentMode, timer, cliReporter, verbose }: EventParams) => {
-  return {
-    startTimer: (message: string) => {
-      console.time(message);
-    },
-    endTimer: (message: string) => {
-      console.timeEnd(message);
-    },
-    waitingMessage: (loadDelayTime: number) => {
-      console.log(
-        'Waiting for ' + loadDelayTime + ' milliseconds after page loads...'
-      );
-    },
-    onTestStart: (url: string) => {
-      if (silentMode) {
-        return;
-      }
-      console.log(
-        bold('\nTesting ' + link(url)) +
-          ' ... please wait, this may take a minute.'
-      );
-      if (timer) {
-        console.time('Total test time');
-      }
-    },
-    onTestComplete: (results: AxeResults) => {
-      const { violations, testEngine, testEnvironment, testRunner } = results;
-
-      /* istanbul ignore if */
-      if (violations.length === 0) {
-        cliReporter(green(' 0 violations found!'));
-        return;
-      }
-
-      const issueCount = violations.reduce((count, violation) => {
-        cliReporter(
-          '\n' +
-            error('  Violation of %j with %d occurrences!\n') +
-            '    %s. Correct invalid elements at:\n' +
-            violation.nodes
-              .map(node => '     - ' + selectorToString(node.target) + '\n')
-              .join('') +
-            '    For details, see: %s',
-          violation.id,
-          violation.nodes.length,
-          violation.description,
-          link(violation.helpUrl.split('?')[0])
-        );
-        return count + violation.nodes.length;
-      }, 0);
-
-      cliReporter(error('\n%d Accessibility issues detected.'), issueCount);
-
-      if (verbose) {
-        const metadata = {
-          'Test Runner': testRunner,
-          'Test Engine': testEngine,
-          'Test Environment': testEnvironment
-        };
-        cliReporter(`\n${JSON.stringify(metadata, null, 2)}`);
-      }
-    }
-  };
-};

package/src/lib/index.ts

@@ -1,5 +0,0 @@
-import testPages from './axe-test-urls';
-import { saveOutcome } from './utils';
-import * as utils from './utils';
-
-export { saveOutcome, testPages, utils };

package/src/lib/utils.test.ts

@@ -1,160 +0,0 @@
-import 'mocha';
-import { assert } from 'chai';
-import tempy from 'tempy';
-import { join } from 'path';
-import { mkdirSync, writeFileSync, rmSync } from 'fs';
-import { dependencies } from '../../package.json';
-import * as utils from './utils';
-
-describe('utils', () => {
-  describe('parseUrl', () => {
-    it('given a url without protocol', () => {
-      const url = 'foobar.com';
-      assert.deepEqual(utils.parseUrl(url), `http://${url}`);
-    });
-    it('given a url with a protocol', () => {
-      const url = 'http://foobar.com';
-      assert.deepEqual(utils.parseUrl(url), url);
-    });
-  });
-
-  describe('parseBrowser', () => {
-    it('given an unknown browser returns error', () => {
-      assert.throws(() => utils.parseBrowser('foobar'));
-    });
-
-    it('given no browser returns chrome-headless', () => {
-      assert.deepEqual(utils.parseBrowser(), 'chrome-headless');
-    });
-
-    describe('returns firefox', () => {
-      const firefoxBrowsers = ['ff', 'firefox', 'gecko', 'marionette'];
-      for (const firefoxBrowser of firefoxBrowsers) {
-        it(`given ${firefoxBrowser} returns firefox`, () => {
-          assert.deepEqual(utils.parseBrowser(firefoxBrowser), 'firefox');
-        });
-      }
-    });
-
-    describe('returns chrome', () => {
-      it('given chrome returns chrome', () => {
-        assert.deepEqual(utils.parseBrowser('chrome'), 'chrome');
-      });
-    });
-
-    describe('returns ie', () => {
-      const ieBrowsers = [
-        'ie',
-        'explorer',
-        'internetexplorer',
-        'internet_explorer',
-        'internet-explorer'
-      ];
-
-      for (const ieBrowser of ieBrowsers) {
-        it(`given ${ieBrowser} returns ie`, () => {
-          assert.deepEqual(utils.parseBrowser(ieBrowser), 'ie');
-        });
-      }
-    });
-
-    describe('returns safari', () => {
-      it('given safari return safari', () => {
-        assert.deepEqual(utils.parseBrowser('safari'), 'safari');
-      });
-    });
-
-    describe('returns edge', () => {
-      const edgeBrowsers = ['edge', 'microsoftedge'];
-      for (const edgeBrowser of edgeBrowsers) {
-        it(`given ${edgeBrowser} returns MicrosoftEdge`, () => {
-          assert.deepEqual(utils.parseBrowser(edgeBrowser), 'MicrosoftEdge');
-        });
-      }
-    });
-  });
-
-  describe('getAxeSource', () => {
-    describe('mock file', () => {
-      function setupTree() {
-        const tempDir = tempy.directory();
-        const parentDirname = join(tempDir, 'node_modules', 'axe-core');
-        mkdirSync(parentDirname, { recursive: true });
-        writeFileSync(join(parentDirname, 'axe.js'), 'parent');
-
-        const cliDirname = join(tempDir, 'packages', 'cli');
-        const nodeModDirname = join(
-          cliDirname,
-          'node_modules',
-          'axe-core'
-        );
-        mkdirSync(nodeModDirname, { recursive: true });
-        writeFileSync(join(nodeModDirname, 'axe.js'), 'node modules');
-
-        const cwdDirname = join(tempDir, 'packages', 'cli', 'lib');
-        mkdirSync(cwdDirname);
-        writeFileSync(join(cwdDirname, 'axe.js'), 'cwd');
-        return {
-          cliDirname,
-          parentDirname,
-          nodeModDirname,
-          cwdDirname
-        };
-      }
-
-      it('uses axe.js from the working directory if it exists', () => {
-        const { cwdDirname } = setupTree();
-        const axeSource = utils.getAxeSource(undefined, cwdDirname);
-        assert.include(axeSource, 'cwd');
-      });
-      it("falls back to axe-core from the working directory's node_modules if axe.js doesn't exist in the working directory", () => {
-        const { cliDirname, cwdDirname } = setupTree();
-        rmSync(join(cwdDirname, 'axe.js'));
-        const axeSource = utils.getAxeSource(undefined, cliDirname);
-        assert.include(axeSource, 'node modules');
-      });
-      it("falls back to axe-core from our own package's node_modules if no working-directory based implementation exists", () => {
-        const { cwdDirname, nodeModDirname } = setupTree();
-        rmSync(join(cwdDirname, 'axe.js'));
-        rmSync(join(nodeModDirname, 'axe.js'));
-        const axeSource = utils.getAxeSource(undefined, cwdDirname);
-        assert.include(axeSource, 'parent');
-      });
-    });
-
-    it('given no axe source use local source', () => {
-      const axeSource = utils.getAxeSource();
-      assert.isNotNull(axeSource);
-    });
-
-    it('given invalid axe source throws error', () => {
-      assert.throws(() => utils.getAxeSource('././././'));
-    });
-  });
-
-  describe('getAxeVersion', () => {
-    it('given valid axe version returns only version', () => {
-      assert.deepEqual(utils.getAxeVersion(`axe.version = '4.1.1'`), '4.1.1');
-    });
-
-    it('given invalid axe version returns unknown version string', () => {
-      assert.deepEqual(utils.getAxeVersion(`axe = '4.1.1'`), 'unknown version');
-    });
-  });
-
-  describe('splitList', () => {
-    it('given a comma delimited string returns array', () => {
-      const delimited = 'foo,bar,baz';
-      const array = utils.splitList(delimited);
-      assert.isArray(array);
-      assert.deepEqual(array, ['foo', 'bar', 'baz']);
-    });
-
-    it('given a single string returns an array', () => {
-      const string = 'foo';
-      const array = utils.splitList(string);
-      assert.isArray(array);
-      assert.deepEqual(array, ['foo']);
-    });
-  });
-});

package/src/lib/utils.ts

@@ -1,155 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import colors from 'colors';
-import { AxeResults } from 'axe-core';
-
-export const saveOutcome = (
-  outcome: AxeResults | AxeResults[],
-  fileName?: string,
-  dir?: string
-): string => {
-  if (typeof fileName !== 'string') {
-    fileName = 'axe-results-' + Date.now() + '.json';
-  }
-  /* istanbul ignore if */
-  if (typeof dir !== 'string') {
-    dir = process.cwd();
-  } else if (!path.isAbsolute(dir)) {
-    dir = path.join(process.cwd(), dir);
-  }
-
-  const filePath = path.join(dir, fileName);
-
-  /* istanbul ignore else */
-  if (!fs.existsSync(filePath)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-  fs.writeFileSync(filePath, JSON.stringify(outcome, null, 2), 'utf-8');
-  return filePath;
-};
-
-export const parseUrl = (url: string): string => {
-  if (!/[a-z]+:\/\//.test(url)) {
-    return 'http://' + url;
-  }
-  return url;
-};
-
-export const parseBrowser = (browser?: string): string | Error => {
-  if (!browser) {
-    return 'chrome-headless';
-  }
-
-  const l = browser.length;
-  switch (browser.toLowerCase()) {
-    case 'ff':
-    case 'firefox'.substr(0, l):
-    case 'gecko'.substr(0, l):
-    case 'marionette'.substr(0, l):
-      return 'firefox';
-
-    case 'chrome'.substr(0, l):
-      return 'chrome';
-
-    case 'ie':
-    case 'explorer'.substr(0, l):
-    case 'internetexplorer'.substr(0, l):
-    case 'internet_explorer'.substr(0, l):
-    case 'internet-explorer'.substr(0, l):
-      return 'ie';
-
-    case 'safari'.substr(0, l):
-      return 'safari';
-
-    case 'edge'.substr(0, l):
-    case 'microsoftedge'.substr(0, l):
-      return 'MicrosoftEdge';
-
-    default:
-      throw new Error('Unknown browser ' + browser);
-  }
-};
-
-export const getAxeSource = (
-  axePath?: string,
-  dirname?: string
-): string | void => {
-  // Abort if axePath should exist, and it isn't
-  if (axePath && !fs.existsSync(axePath)) {
-    return;
-  }
-
-  let cwd = dirname;
-  if (!cwd) {
-    cwd = process.cwd();
-  }
-
-  if (!dirname) {
-    dirname = __dirname;
-  }
-
-  // Look for axe in current working directory
-  if (!axePath) {
-    axePath = path.join(cwd, 'axe.js');
-  }
-
-  if (!fs.existsSync(axePath)) {
-    // Look for axe in CWD ./node_modules
-    axePath = path.join(cwd, 'node_modules', 'axe-core', 'axe.js');
-  }
-
-  if (!fs.existsSync(axePath)) {
-    // `__dirname` is /@axe-core/cli/dist/src/lib when installed globally
-    // to access the locally installed axe-core package we need to go up 3 levels
-    // if all else fails, use the locally installed axe
-    axePath = path.join(
-      dirname,
-      '..',
-      '..',
-      '..',
-      'node_modules',
-      'axe-core',
-      'axe.js'
-    );
-  }
-
-  return fs.readFileSync(axePath, 'utf-8');
-};
-
-export const getAxeVersion = (source: string): string => {
-  const match = source.match(/\.version\s*=\s'([^']+)'/);
-  return match ? match[1] : 'unknown version';
-};
-
-export const splitList = (val: string): string[] => {
-  return val.split(/[,;]/).map(str => str.trim());
-};
-
-export const selectorToString = (
-  selectors: string[],
-  separator?: string
-): string => {
-  separator = separator || ' ';
-  return selectors
-    .reduce((prev, curr) => prev.concat(curr as never), [])
-    .join(separator);
-};
-
-export const reporter = (
-  noReporter: boolean,
-  silentMode: boolean
-): (() => void) => {
-  if (!noReporter || silentMode) {
-    return () => {};
-  } else {
-    return (...args: string[]) => {
-      console.log(...args);
-    };
-  }
-};
-
-export const link = colors.underline.blue;
-export const error = colors.red.bold;
-export const bold = colors.bold;
-export const green = colors.green;
-export const italics = colors.italic;

package/src/lib/webdriver.test.ts

@@ -1,104 +0,0 @@
-import 'mocha';
-import { assert } from 'chai';
-import { startDriver } from './webdriver';
-import { WebDriver } from 'selenium-webdriver';
-import chromedriver from 'chromedriver';
-import chrome from 'selenium-webdriver/chrome';
-import type { Options } from 'selenium-webdriver/chrome';
-import path from 'path';
-import { WebdriverConfigParams } from '../types';
-describe('startDriver', () => {
-  let config: WebdriverConfigParams;
-  let browser: string;
-  let driver: WebDriver;
-  beforeEach(() => {
-    browser = 'chrome-headless';
-    config = {
-      timeout: 90,
-      get browser() {
-        return browser;
-      }
-    };
-  });
-
-  afterEach(async () => {
-    await driver.quit();
-  });
-
-  it('creates a driver', async () => {
-    driver = await startDriver(config);
-    assert.isObject(driver);
-    assert.isFunction(driver.manage);
-  });
-
-  xit('sets the config.browser as the browser', async () => {
-    browser = 'chrome';
-    driver = await startDriver(config);
-    const capabilities = await driver.getCapabilities();
-    assert.equal(capabilities.get('browserName'), browser);
-  });
-
-  it('sets the browser as chrome with chrome-headless', async () => {
-    browser = 'chrome-headless';
-    driver = await startDriver(config);
-    const capabilities = await driver.getCapabilities();
-
-    assert.equal(capabilities.get('browserName'), 'chrome');
-  });
-
-  it('uses the chromedriver path with chrome-headless', async () => {
-    browser = 'chrome-headless';
-    driver = await startDriver(config);
-    const chromedriverPath = (config as any).builder.chromeService_.exe_;
-
-    assert.equal(chromedriverPath, chromedriver.path);
-  });
-
-  it('uses the passed in chromedriver path with chrome-headless', async () => {
-    browser = 'chrome-headless';
-    config.chromedriverPath = path.relative(process.cwd(), chromedriver.path);
-    driver = await startDriver(config);
-    const chromedriverPath = (config as any).builder.chromeService_.exe_;
-
-    assert.notEqual(config.chromedriverPath, chromedriver.path);
-    assert.equal(chromedriverPath, config.chromedriverPath);
-  });
-
-  it('passes the --no-sandbox argument to chromeOptions', async () => {
-    browser = 'chrome-headless';
-    config.chromeOptions = ['--no-sandbox'];
-    driver = await startDriver(config);
-
-    const options = config?.builder?.getChromeOptions();
-    assert.isArray(options?.get('goog:chromeOptions').args);
-    assert.deepEqual(options?.get('goog:chromeOptions').args, [
-      'headless',
-      '--no-sandbox'
-    ]);
-  });
-
-  it('passes multiple arguments argument to chromeOptions', async () => {
-    browser = 'chrome-headless';
-    config.chromeOptions = ['no-sandbox', 'disable-dev-shm-usage'];
-    driver = await startDriver(config);
-
-    const options = config?.builder?.getChromeOptions();
-    assert.isArray(options?.get('goog:chromeOptions').args);
-    assert.deepEqual(options?.get('goog:chromeOptions').args, [
-      'headless',
-      'no-sandbox',
-      'disable-dev-shm-usage'
-    ]);
-  });
-
-  it('sets the --timeout flag', async () => {
-    browser = 'chrome-headless';
-    config.timeout = 10000;
-    driver = await startDriver(config);
-    config.builder;
-    const timeoutValue = await driver.manage().getTimeouts();
-
-    assert.isObject(timeoutValue);
-    assert.deepEqual(timeoutValue.script, 10000000);
-  });
-});