WebDriverIO Automated App Testing

First, make sure you have installed NodeJS. If you haven't, you can easily install it by downloading NodeJS from https://nodejs.org/en/download/

See our WebdriverIO examples repository for some examples on how to use WebdriverIO with TestingBot.

Installation

TestingBot has its own WebDriverIO service plugin which makes configuring your tests easier and which sends test meta-data back to TestingBot.

Let's start with making sure webdriverio is installed:

npm i --save-dev @wdio/cli @wdio/local-runner

You are now ready to run a WebDriver test with NodeJS on our grid.

WebDriverIO TestingBot Service

WebDriverIO contains a TestingBot service which makes it easy to run tests with WebDriverIO on TestingBot. With this service, WebDriverIO will start a TestingBot Tunnel if required, and send back test meta-data (passed state, name, build-id, ...)

In order to use the service you need to download it from NPM:

npm install @wdio/testingbot-service --save-dev

Mocha Example

To run Mocha tests on TestingBot, please follow these steps:

npm install @wdio/testingbot-service --save-dev
npm install @wdio/dot-reporter --save-dev
npm install @wdio/mocha-framework --save-dev

Now we'll make a simple Mocha test which uses Firefox on TestingBot to go to Google.com and verify the page's title.

Please create the following files:

wdio.conf.js

exports.config = {

	/**
	 * specify test files
	 */
	specs: [
		'./runner-specs/mocha.test.js'
	],

	/**
	 * capabilities
	 */
	capabilities: [{
		name: 'My First App Test',
		deviceName: 'Pixel 8',
		platformName: 'Android',
		version: '14.0',
		app: 'https://testingbot.com/appium/sample.apk'
	}],

	/**
	 * test configurations
	 */
	logLevel: 'silent',
	coloredLogs: true,
	screenshotPath: 'screenshots',
	waitforTimeout: 10000,
	framework: 'mocha',
	services: [
        ['testingbot']
    ],
	user: 'api_key',
	key: 'api_secret',

	reporters: ['dot'],
	reporterOptions: {
		outputDir: './'
	},

	mochaOpts: {
		ui: 'bdd'
	}
};

runner-specs/mocha.test.js

const assert = require('assert')
describe('calculator', function() {
        it('should calculate a sum', async () => {
            const inputA = await $('~inputA')
            await inputA.waitForDisplayed(5000)
            await inputA.click()
            try {
                    await inputA.addValue('10')
            } catch (e) {}

            const inputB = await $('~inputB')
            await inputB.waitForDisplayed(5000)
            await inputB.click()
            try {
                    await inputB.addValue('5')
            } catch (e) {}

            const sumElement = await $('~sum')
            const sum = await sumElement.getText()
            assert.equal(sum, '15') // 10 + 5
        })
})

Now we can run this mobile app test on TestingBot. The test will do a simple sum calculation and verify if the calculation was correct.
To start the test, please run this command:

~/node_modules/.bin/wdio run wdio.conf.js

The test will now run on TestingBot. At the end of the test, the testname and success state will be available on TestingBot, together with a video and other meta-data.

Uploading Your App

Please see our Upload Mobile App documentation to find out how to upload your app to TestingBot for testing.

Specify Browsers & Devices

To run your existing tests on TestingBot, your tests will need to be configured to use the TestingBot remote machines. If the test was running on your local machine or network, you can simply change your existing test like this:

Before:

export.config = {
  // ...
  services: ['selenium-standalone'],
  // ...
};

After:

export.config = {
	// ...
	services: [
        ['testingbot']
    ],
	user: process.env.TB_KEY,
	key: process.env.TB_SECRET,
	// ...
};

To let TestingBot know on which device you want to run your test on, you need to specify the deviceName, version, platformName and other optional options in the capabilities field.

To see how to do this, please select a combination of device type and device name in the drop-down menus below.

1. Select a Device Type

2. Select a Device Name

Testing Internal Websites

We've built TestingBot Tunnel, to provide you with a secure way to run tests against your staged/internal webapps.
Please see our TestingBot Tunnel documentation for more information about this easy to use tunneling solution.

The example below shows how to easily run a WebdriverIO test with our Tunnel:

1. Adjust your wdio.conf.js configuration to use tbTunnel: true.
The wdio-testingbot-service will automatically download and use the tunnel for your tests.

wdio.conf.js

exports.config = {
	services: [
        ['testingbot', {
            tbTunnel: true
        }]
    ],
	user: 'api_key',
	key: 'api_secret'
};

Run tests in Parallel

Parallel Testing means running the same test, or multiple tests, simultaneously. This greatly reduces your total testing time.

You can run the same tests on all different browser configurations or run different tests all on the same browser configuration.
TestingBot has a large grid of machines and browsers, which means you can use our service to do efficient parallel testing. It is one of the key features we provide to greatly cut down on your total testing time.

To run tests in parallel, you can use WebDriverIO's MultiRemote feature where you specify multiple desired capabilities for your tests.

Queuing

Every plan we provide comes with a limit of parallel tests.
If you exceed the number of parallel tests assigned to your account, TestingBot will queue the additional tests (for up to 6 minutes) and run the tests as soon as slots become available.

Mark tests as passed/failed

As TestingBot has no way to dermine whether your test passed or failed (it is determined by your business logic), we offer a way to send the test status back to TestingBot. This is useful if you want to see if a test succeeded or failed from the TestingBot member area.

If you are using the wdio-testingbot-service then your tests will automatically report back meta-data to TestingBot (like test success, name, stacktrace, ...)

Preparing your App

You do not need to install any code or plugin to run a test.
Below are some things that are necessary to successfully run a mobile test:

For Android:

Please supply the URL to your .apk or .aab file.
Important: the .apk file needs to be a x86 build (x86 ABI) for Android emulators.

For iOS Real Device:

Please supply the URL to an .ipa file.

For iOS Simulator:

Please supply the URL to a .zip file that contains your .app
The .app needs to be an iOS Simulator build:
- Create a Simulator build:
```
xcodebuild -sdk iphonesimulator -configuration Debug
```
- Zip the .app bundle:
```
zip -r MyApp.zip MyApp.app
```

Additional Options

Appium provides a lot of options to configure your test.

Some important options that might help:

For Android:

appActivity and appPackage: by default, Appium will try to extract the main Activity from your apk. If this fails, you can supply your own with these options.
chromeOptions: additional chromedriver options you can supply.
otherApps: a JSON array of other apps that need to be installed, in URL format.

For Android & iOS:

locale: the language of the simulator/device (ex: fr_CA)
newCommandTimeout: How long (in seconds) Appium will wait for a new command from the client before assuming the client quit and ending the session

Cross Browser Testing

Live Testing

Visual Testing

Smart-TV Testing

Automated App Testing

Live App Testing

Codeless Automation

Headless Testing

Automation Frameworks