webdriver.test.ts

import 'mocha';
import { assert } from 'chai';
import { startDriver } from './webdriver';
import { WebDriver } from 'selenium-webdriver';
import chrome from 'selenium-webdriver/chrome';
import path from 'path';
import { WebdriverConfigParams } from '../types';
import sinon from 'sinon';
import { CHROME_TEST_PATH, CHROMEDRIVER_TEST_PATH } from './utils';

describe('startDriver', () => {
  let config: WebdriverConfigParams;
  let browser: string;
  let driver: WebDriver;
  before(() => {
    assert(
      process.env.CHROME_TEST_PATH,
      [
        'CHROME_TEST_PATH is not set.',
        'Install Chrome: npx @puppeteer/browsers install chrome@stable',
        'The command prints the resolved binary path; export it as CHROME_TEST_PATH.',
        'e.g. export CHROME_TEST_PATH="$(npx @puppeteer/browsers install chrome@stable | awk \'{print $2}\')"'
      ].join('\n')
    );
    assert(
      process.env.CHROMEDRIVER_TEST_PATH,
      [
        'CHROMEDRIVER_TEST_PATH is not set.',
        'Install ChromeDriver: npx @puppeteer/browsers install chromedriver@stable',
        'The command prints the resolved binary path; export it as CHROMEDRIVER_TEST_PATH.',
        'e.g. export CHROMEDRIVER_TEST_PATH="$(npx @puppeteer/browsers install chromedriver@stable | awk \'{print $2}\')"'
      ].join('\n')
    );
  });
  beforeEach(() => {
    browser = 'chrome-headless';
    config = {
      timeout: 90,
      get browser() {
        return browser;
      }
    };
  });

  afterEach(async () => {
    // try catch required due to `chrome.options` being mocked with sinon
    // and not properly creating a driver
    try {
      await driver.quit();
    } catch (error) {}
  });

  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();
    // https://github.com/seleniumbase/SeleniumBase/issues/2343\
    assert.include(capabilities.get('browserName'), 'chrome');
  });

  it('uses the chrome path with chrome-headless', async () => {
    browser = 'chrome-headless';
    driver = await startDriver(config);
    const options = config?.builder?.getChromeOptions();
    const chromePath = (options as any).get('goog:chromeOptions').binary;
    assert.equal(chromePath, CHROME_TEST_PATH);
  });

  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_TEST_PATH);
  });

  it('uses the passed in chromedriver path with chrome-headless', async () => {
    browser = 'chrome-headless';
    config.chromedriverPath = path.relative(
      process.cwd(),
      CHROMEDRIVER_TEST_PATH as string
    );
    driver = await startDriver(config);
    const chromedriverPath = (config as any).builder.chromeService_.exe_;

    assert.notEqual(config.chromedriverPath, CHROMEDRIVER_TEST_PATH);
    assert.equal(chromedriverPath, config.chromedriverPath);
  });

  it('passes multiple arguments argument to chromeOptions', async () => {
    browser = 'chrome-headless';
    config.chromeOptions = ['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',
      'disable-dev-shm-usage',
      'no-sandbox'
    ]);
  });

  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);
  });

  it('invokes `options.headless()` on versions of selenium-webdriver < 4.17.0', async () => {
    const stub = sinon.stub(chrome, 'Options').returns({
      headless: () => {}
    });

    // try catch required due to `chrome.options` being mocked with sinon
    // and not properly creating a driver
    try {
      driver = await startDriver(config);
    } catch (error) {}
    assert.isTrue(stub.calledOnce);
    stub.restore();
  });
});