@axe-core/cli 4.8.0 → 4.8.1-5bfd440.0

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,147 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import colors from 'colors';
-import type { AxeResults, UnlabelledFrameSelector } 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)) {
-    // in local develop using npm workspaces axe-core is
-    // hoisted to the root, but when published axe-core
-    // will be in the node_modules for the cli
-    axePath = require.resolve('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: UnlabelledFrameSelector,
-  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);
-  });
-});

package/src/lib/webdriver.ts

@@ -1,43 +0,0 @@
-import path from 'path';
-import chromedriver from 'chromedriver';
-import { Builder, type WebDriver } from 'selenium-webdriver';
-import chrome from 'selenium-webdriver/chrome';
-import { WebdriverConfigParams } from '../types';
-
-const startDriver = async (
-  config: WebdriverConfigParams
-): Promise<WebDriver> => {
-  const scriptTimeout = config.timeout * 1000.0;
-  let builder: Builder;
-  /* istanbul ignore else */
-  if (config.browser === 'chrome-headless') {
-    const service = new chrome.ServiceBuilder(
-      config.chromedriverPath || chromedriver.path
-    );
-
-    let options = new chrome.Options().headless();
-    if (config.chromeOptions?.length) {
-      options = config.chromeOptions.reduce(function (options, arg) {
-        return options.addArguments(arg);
-      }, options);
-    }
-
-    if (config.chromePath) {
-      options.setChromeBinaryPath(path.resolve(config.chromePath));
-    }
-
-    builder = new Builder()
-      .forBrowser('chrome')
-      .setChromeOptions(options)
-      .setChromeService(service);
-  } else {
-    builder = new Builder().forBrowser(config.browser);
-  }
-
-  config.builder = builder;
-  const driver = builder.build();
-  await driver.manage().setTimeouts({ script: scriptTimeout });
-  return driver;
-};
-
-export { startDriver };