How to use webdriverio - 10 common examples

async function runJsUnitTestsInBrowser() {
  var options = {
      capabilities: {
          browserName: 'chrome'
      }
  };

  var url = 'file://' + __dirname + '/index.html';
  console.log('Starting webdriverio...');
  const browser = await webdriverio.remote(options);
  console.log('Initialized.\nLoading url: ' + url);
  await browser.url(url);

  const elem = await browser.$('#closureTestRunnerLog')
  const result = await elem.getHTML();

  // call js to parse html
  var regex = /[\d]+\spassed,\s([\d]+)\sfailed./i;
  var numOfFailure = regex.exec(result)[1];
  var regex2 = /Unit Tests for Blockly .*]/;
  var testStatus = regex2.exec(result)[0];
  console.log('============Blockly Unit Test Summary=================');
  console.log(testStatus);
  var regex3 = /\d+ passed,\s\d+ failed/;
  var detail = regex3.exec(result)[0];
  console.log(detail);

function startWorker (device, done) {

    var client = webdriverio.remote(device);

    // report result
    var reportResultRegEx = /^\d+ specs, (\d+) failure/;
    var reportResult;
    var ignoreMsgRegEx = /ConsoleReporter/;

    /**
     * 桥循环
     *
     * @param  {number} timeout    超时时间
     * @param  {string} timeoutMsg 超时信息
     * @param  {number} interval   循环间隔
     * @return {client}            webdrive client
     */
    function bridgeLoop(timeout, timeoutMsg, interval) {

var kakuPath;

// Note
// we only support Mac & linux platform for uitest for now.
switch (process.platform) {
  case 'darwin':
    kakuPath = './build/Kaku-darwin-x64/Kaku.app/Contents/MacOS/Electron';
    break;

  default:
    kakuPath = './build/app/Kaku';
    break;
}

var client = webdriverio.remote({
  host: 'localhost',
  port: 9515,
  desiredCapabilities: {
    browserName: 'chrome',
    chromeOptions: {
      binary: kakuPath
    }
  }
});

var assert = require('assert');
var chai = require('chai');

// Note
// we will create a child process for chromeDriver when running tests
beforeEach((done) => {

data;

  if(env == 'vg1' || env == 'vg2') {
    spec = JSON.parse(fs.readFileSync('spec/'+env+'/'+spec+'.json'));

    var data = spec.data[0];
    if(data.url) {
      data.values = JSON.parse(fs.readFileSync(data.url));
      delete data.url;
    }    
  } else {
    spec = require('./spec/d3/'+spec);
    if(spec.data) data = JSON.parse(fs.readFileSync(spec.data));
  }

  var client = webdriverio.remote({
      desiredCapabilities: {
        browserName: 'chrome',
        chromeOptions: {
          args: ['--enable-precise-memory-info']
        }
      }
    })
    .init()
    .url('http://localhost:8000/benchmarks/'+env+'.html')
    .timeoutsAsyncScript(3000000)
    .execute(function(env, specName, spec, data, N, C) {
      this.N = N;
      this.C = C;
      
      // Inject data generation into the browser because Selenium throws an error
      // if we send in a large pre-injected spec

/* global appController */

/**
 * This tests fails if you clap or scream while the test is running
 *
 * @author Christian Bromann 
 * @license MIT
 */

var WebdriverIO = require('webdriverio')
var WebdriverRTC = require('../')
var assert = require('assert')
var inputLevel

var matrix = WebdriverIO.multiremote({
    browserA: {
        desiredCapabilities: {
            browserName: 'chrome',
            chromeOptions: { args: ['use-fake-ui-for-media-stream'] }
        }
    },
    browserB: {
        desiredCapabilities: {
            browserName: 'chrome',
            chromeOptions: { args: ['use-fake-ui-for-media-stream'] }
        }
    }
})

WebdriverRTC.init(matrix, {
    browser: 'browserA'

let envValues = `LOCALE=${locale} `;
        let exitProcess = false;
        process.on('SIGINT', () => {
          exitProcess = true;
        });

        const form = factors[factor];
        if (form) {
          process.env.FORM_FACTOR = form;
          envValues += `FORM_FACTOR=${form}`;
        }
        envValues = Logger.emphasis(envValues);
        Logger.log(`Running tests for: ${envValues}`, { context });

        // eslint-disable-next-line no-await-in-loop
        await new Launcher(configPath, testSetup)
          .run()
          .then(
            (code) => {
              // If we receive a test failure, exit with a status of 1.  exitProcess is a special case
              // where the user hit Ctrl-C and will be handled in the else block.
              if (code === 1 && !continueOnFail && !exitProcess) {
                Logger.error(`Running tests for: ${envValues} failed.`, { context });
                process.exit(1);
              } else {
                onReturnSuccess(exitProcess, envValues);
              }
            },
            (error) => {
              Logger.error(`Launcher failed to start the test ${error.stacktrace}`, { context });
              process.exit(1);
            },

const locale = locales[localeI];
    process.env.LOCALE = locale;

    for (let factor = 0; factor < factors.length; factor += 1) {
      let envValues = `LOCALE=${locale} `;

      const form = factors[factor];
      if (form) {
        process.env.FORM_FACTOR = form;
        envValues += `FORM_FACTOR=${form}`;
      }
      envValues = Logger.emphasis(envValues);
      Logger.log(`Running tests for: ${envValues}`, { context });

      // eslint-disable-next-line no-await-in-loop
      await new Launcher(configPath, testSetup)
        .run()
        .then(
          (code) => {
            if (code === 1 && !continueOnFail) {
              Logger.error(`Running tests for: ${envValues} failed.`, { context });
              process.exit(1);
            } else {
              Logger.log(`Finished tests for: ${envValues}\n\n---------------------------------------\n`, { context });
            }
          },
          (error) => {
            Logger.error(`Launcher failed to start the test ${error.stacktrace}`, { context });
            process.exit(1);
          },
        );
    }

console.log(
  `\nExpecting a player build served at port: ${process.env.http || '8080'}\n`
);

// start browserstack-local for testing
console.log('Connecting local to browserstack automate...');
let bs_local_args = {
  key: key,
  localIdentifier: localIdentifier,
  force: true,
  logfile: './browserstackLocal.log'
};

bs_local = new browserstacklocal.Local();
wdio.bs_local = bs_local;

// bs_local.stop(function() {
//   console.log('Stopped BrowserStackLocal');
// });

// start: function() {

bs_local.start(bs_local_args, async function(err) {
  if (err) {
    console.log('its done and not working', err.message);
  }
  console.log(
    'Connected.\n\nNight gathers, and now my watch begins..\nI am the sword in the darkness.\n'
  );
  // check if BrowserStack local instance is running
  console.log(

public async launch(desiredCapabilities?: WebDriver.DesiredCapabilities) {
    logger.debug("Browser: launch");

    this._browser = await remote({
      // default to chrome
      capabilities: desiredCapabilities || this.getChromeCapabilities(),
      logLevel: "warn",
      port: CONFIG.seleniumPort
    });

    this._browser!.setTimeout({ script: 300 * 1000 });
  }

capabilities: config,

    coloredLogs: true,
    screenshotPath: './errorShots/',
    baseUrl: '',
    waitforTimeout: 10000,
    connectionRetryTimeout: 90000,
    connectionRetryCount: 3,
    host: 'hub.browserstack.com'
  };
  const extendedOptions = Object.assign(defaults, options);
  if (config.logLevel) {
    // OPTIONS: verbose | silent | command | data | result
    extendedOptions.logLevel = config.logLevel;
  }
  global.browser = await wdio.remote(extendedOptions);
  return browser;
};