@axe-core/cli 4.7.4-cbd2a5f.0 → 4.8.0

package/src/lib/utils.ts

@@ -0,0 +1,147 @@
+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

@@ -0,0 +1,104 @@
+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

@@ -0,0 +1,43 @@
+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 };