During the development of your test suite, it & # x27; s helpful to run test one at a clip, and on one target platform at a time. But when it comes to a product CI surroundings, you & # x27; re decidedly going to want to run your exam in parallel, with as high a concurrency as you can manage. We & # x27; ve already looked at, and it involves setting up specific capability in your test to make certain that, for each test, Appium can instantiate an appropriate driver without step on the toes of the drivers runningother tests.

Scaling Up Parallel Testing

This approach only scales so far, however. There & # x27; s a limit to how many real or practical devices you can run on one machine. What if you want to run 100 Appium? You & # x27; re likely not going to be capable to do that all with one Appium waiter. Or what if you & # x27; re running a web exam, and would like to make sure your testing plant on desktop browser as well as mobile device? For that you & # x27; ll need to mix in Selenium. Either way, you & # x27; re eventually going to run into a situation where you need multiple automation servers running, which adds a lot of complexness to your exam playscript. Now your test script needs to know the host and port of each server, which servers host which devices or browsers, and how to make sure it doesn & # x27; t start too many tests on one host and overload its capacity. Essentially, you & # x27; re dealing with an execution model that looks like this:

(In this example, we & # x27; re prove to run a web test in parallel across Safari on iOS, Chrome on Android, and Chrome on Desktop).

Check out:

Selenium Grid

Thankfully, there & # x27; s a way to mitigate all this complexity, by using a special-purposeload balancer called Selenium Grid. Selenium Grid is basically a proxy server that speaks the WebDriver protocol, and manages connections to a pool of WebDriver servers. It wasn & # x27; t design specifically to work with Appium, but because Appium also speaks the WebDriver protocol (and because we taught Appium how to file with Selenium Grid), it & # x27; s the best tool for DIY Appium clump.

Also check:

Here & # x27; s how Selenium Grid works:

1. You begin a Selenium server running in & quot; hub & quot; mode on a certain horde and porthole of your choosing.
2. Now, you can commence any number of other Selenium or Appium servers in & quot; node & quot; mode. You can start them anywhere you like, as long as they have network admission to the grid host (the & quot; hub & quot;).
3. Each node is depart with a special & quot; node config & quot; that describes the kinds of automation potentiality it supports.
4. Now, when your exam needs to start a session, you assure it targets the grid server, and the grid server will resolve which node to use for the session. You don & # x27; t need to know or care about where the knob are situate. As long as your test specifies capabilities which the hub can match to a complimentary node, your test will run.

Read:

In early words, I & # x27; ve been describing a model that appear more like this:

Beyond the simplicity of require to know simply about one test waiter, the Selenium Grid model is especially nice for Appium, because Appium driver also ask a routine of scheme resources (unique embrasure, etc ...). On the Grid model, you can start each Appium server independently, with a predefined set of embrasure or the like, using the -- default-capabilities flag. So, for example, I could commence a set of Appium server like this, also using the -- nodeconfig flag to tell Appium it should relate with Selenium Grid:

appium -- default-capabilities= ' {`` wdaLocalPort '': 8100} ' -- nodeconfig=/path/to/nodeconfig.json appium -- default-capabilities= ' {`` wdaLocalPort '': 8200} ' -- nodeconfig=/path/to/nodeconfig.json

Now each of these Appium servers will be register with the Selenium Grid, and each waiter has declared which wdaLocalPort it needs; now my test handwriting doesn & # x27; t have to know or care about this! It becomes an ops step, which get much more sentiency.

Accelerate Appium test cycles with the HeadSpin.Learn more.

Node Config

The magic middling much all hap in the & quot; node config & quot; file, which is defined as JSON. There are a lot ofnodeconfig optionsto take from, but here & # x27; s an example of the config I & # x27; ll be using for the Safari-on-iOS node in this guide:

Pro tip: Tools like SUSA can handle this autonomously — upload your app and get results without writing a single test script.

{`` capabilities '': [{`` deviceName '': `` iPhone 8 '', `` platformVersion '': `` 11.4 '', `` maxInstances '': 1, `` platformName '': `` iOS '', `` browserName '': `` Safari ''}], `` shape '': {`` cleanUpCycle '' :2000, `` timeout '' :30000, `` proxy '': `` org.openqa.grid.selenium.proxy.DefaultRemoteProxy '', `` maxSession '': 1, `` register '': true, `` registerCycle '': 5000, `` hubPort '': 4444, `` hubHost '': `` 127.0.0.1 '', `` hubProtocol '': `` http ''}}

Let & # x27; s occupy a look at some of the important configuration keys:

• capabilities: the set of capabilities back by this node. Can be a list. In this case, the node is only indorse one type of device. Note that in addition to the capabilities you & # x27; re used to witness, you can delimit how many of a particular capability set the node should be allowed to begin, via maxInstances.
• procurator: the placeholder logic to be used for communicate with this node. You can indite a custom proxy if desired.
• maxSession: the total number of sessions this node can run. This is useful in combination with maxInstances. For example, let & # x27; s say we can run a total of 5 iPhone 8s and 5 iPhone 6s on this node, but the scheme gets overloaded when running more than 8 session at a clip, ofanykind. Then we & # x27; d set maxInstances to 5 for each device type, but maxSession to 8, so that we never try to run the theoretical max of 10.
• hubHost, hubPort, and hubProtocol: the connection details for the Grid hub server

Read:

Starting Up the Grid

That & # x27; s basically all you need to know about how Selenium Grid act with Appium. So let & # x27; s dive into a working example. What we want to end up with is parallel executing of one web test, across Safari on iOS, Chrome on Android, and Chrome on Desktop (just like in the diagrams above).

1. Make sure you & # x27; ve downloadedthe modish Selenium server(I & # x27; m on 3.141.59 for this guide).
2. Make sure you & # x27; ve got the up-to-the-minuteChromedriver, so that Chrome desktop automation works (I & # x27; m on 2.45).
3. Make sure you & # x27; ve got an Android emulator up and running with the latest version of the Chrome browser on it (I & # x27; m utilisev71).
4. Open up 4 separate terminal windows (we & # x27; re depart to run the Grid hub server in one, and the 3 nodes in the others). Here & # x27; s what to run in the 4 windows (in all cases, replace the paths with appropriate way for your system):

# Window 1: the Grid hub java -jar /path/to/selenium-server-standalone.jar -role hub # Window 2: the iOS node appium -p 4723 -- nodeconfig /path/to/nodeconfig-ios.json # Window 3: the Android node appium -p 4733 -- nodeconfig /path/to/nodeconfig-android.json # Window 4: the Chrome desktop node java -Dwebdriver.chrome.driver= '' /path/to/chromedriver '' -jar /path/to/selenium-server-standalone.jar -role node -nodeConfig /path/to/nodeconfig-chrome.json

Here are the content of the nodeconfig JSON files (in addition to nodeconfig-ios.json, which is above). (You can also download themfrom the Appium Pro repo on GitHub).

nodeconfig-android.json:

{`` capabilities '': [{`` browserName '': `` Chrome '', `` platformVersion '': `` 26 '', `` maxInstances '': 1, `` platformName '': `` Android '', `` automationName '': `` UiAutomator2 '', `` deviceName '': `` Android Emulator ''}], `` configuration '': {`` cleanUpCycle '' :2000, `` timeout '' :30000, `` proxy '': `` org.openqa.grid.selenium.proxy.DefaultRemoteProxy '', `` maxSession '': 1, `` registry '': true, `` registerCycle '': 5000, `` hubPort '': 4444, `` hubHost '': `` 127.0.0.1 '', `` hubProtocol '': `` http ''}}

nodeconfig-chrome.json:

{`` capabilities '': [{`` browserName '': `` chrome '', `` browserVersion '': `` 71 '', `` platformName '': `` MAC '', `` maxInstances '': 1}], `` cleanUpCycle '' :2000, `` timeout '' :30000, `` proxy '': `` org.openqa.grid.selenium.proxy.DefaultRemoteProxy '', `` maxSession '': 1, `` registry '': true, `` registerCycle '': 5000, `` hubPort '': 4444, `` hubHost '': `` 127.0.0.1 '', `` hubProtocol '': `` http ''}

Also read:

This is all the frame-up we involve! In a real production CI environment, you & # x27; d probably have this all automate and potentially registering lots more nodes across many different physical or practical servers. Anyway, once you & # x27; ve got everything up and running, you should see message in the Selenium Grid console to the effect that several thickening have checked in:

13:48:04.514 INFO [DefaultGridRegistry.add] - Registered a node http: //0.0.0.0:4733

Check:

Running Tests on the Grid

Because our test project is Gradle-based, our good option for scat in parallel is to use maxParallelForks (as described in, along with instructions for Maven-based projects). Here & # x27; s how I & # x27; ve updated my build.gradle to that end:

exam {maxParallelForks = 3 forkEvery = 1}

This will cause Gradle to create a new thread for each test form. Unfortunately, a consequence is that for real parallelism, we need to have separate tryout classes, not just separate methods within one exam. For that reason, this example include 4 Java files: one as a basal trial form for shared codification, and 3 platform-specific classes, so that they can be run in latitude. Here & # x27; s the base course:

public class Edition054_Selenium_Grid {protected RemoteWebDriver driver; static String HUB_URL = `` http: //localhost:4444/wd/hub ''; individual static By loginBtn = By.tagName (`` button ''); private static By username = By.id (`` username ''); private still By word = By.id (`` password ''); individual static By message = By.id (`` flashing ''); individual still String LOGIN_URL = `` https: //the-internet.herokuapp.com/login ''; individual static String ERR_MSG = `` Your username is invalid! ``; @ After public void tearDown () {if (driver! = null) {driver.quit ();}} protected void actualTest (RemoteWebDriver driver) {WebDriverWait expect = new WebDriverWait (driver, 10); driver.navigate () .to (LOGIN_URL); wait.until (ExpectedConditions.presenceOfElementLocated (username)) .sendKeys (`` foo ''); driver.findElement (password) .sendKeys (`` bar ''); driver.findElement (loginBtn) .click (); String errText = wait.until (ExpectedConditions.presenceOfElementLocated (substance)) .getText (); Assert.assertThat (errText, Matchers.containsString (ERR_MSG));}}

Read:

As you can see, it contains the actual trial logic we want to action, which attempts a login onThe Internetand checks that the login fails. The sole real point of interest here is that we get saved a reference to the Grid hub server, running on the default port 4444. This is what each test class will use to connect to the Grid hub.

And here are the three platform-specific classes:

public class Edition054_Selenium_Grid_IOS extends Edition054_Selenium_Grid {@ Test world vacancy testIOS () throws MalformedURLException {DesiredCapabilities cap = new DesiredCapabilities (); caps.setCapability (`` platformName '', `` iOS ''); caps.setCapability (`` platformVersion '', `` 11.4 ''); caps.setCapability (`` deviceName '', `` iPhone 8 ''); caps.setCapability (`` browserName '', `` Safari ''); driver = new RemoteWebDriver (new URL (HUB_URL), detonator); actualTest (driver);}} public class Edition054_Selenium_Grid_Android extends Edition054_Selenium_Grid {@ Test public void testAndroid () throws MalformedURLException {DesiredCapabilities caps = new DesiredCapabilities (); caps.setCapability (`` platformName '', `` Android ''); caps.setCapability (`` deviceName '', `` Android Emulator ''); caps.setCapability (`` automationName '', `` UiAutomator2 ''); caps.setCapability (`` browserName '', `` Chrome ''); driver = new RemoteWebDriver (new URL (HUB_URL), caps); actualTest (driver);}} public grade Edition054_Selenium_Grid_Desktop extends Edition054_Selenium_Grid {@ Test public vacuum testDesktop () throws MalformedURLException {DesiredCapabilities crest = new DesiredCapabilities (); caps.setCapability (`` browserName '', `` chrome ''); caps.setCapability (`` browserVersion '', `` 71 ''); caps.setCapability (`` platformName '', `` MAC ''); driver = new RemoteWebDriver (new URL (HUB_URL), caps); actualTest (driver);}}

The only responsibility for these category is to get the correct capabilities set up, instantiate a driver with them, and kick off the actual test. With each of these family set up in their own files appropriately, I can now use a gradle command to run my test suite in parallel:

./gradlew: cleanTest: test -- tests `` Edition054_Selenium_Grid.Edition054_Selenium_Grid_ * ''

(The * helps me select all the test classes I care about for this example, and not other unity).

At this point, all three tests are started simultaneously, and Selenium Grid forward each session to the appropriate node. The result is that all the tests accomplish at the same time (though on my machine, the Chrome Desktop test ends much faster than the early two)!

Optimize digital experience with the mobile app performance quiz capabilities of the HeadSpin.Learn more.

Wrap-up

Selenium Grid, and deal in general, is a deep topic, and this guide could only extend the canonic cases. But what we & # x27; ve shown is enough to use to get a examination grid of basically any size up and running, potentially still mixing and fit peregrine and desktop testing as well.

What you & # x27; ll no doubt find as you get into put up your own Grid is that, fabulous as Selenium Grid itself may be, there & # x27; s an awful lot of maintenance associated with running the various node! That & # x27; s one reason that there are, nowadays, a number of selection for running your Appium exam in parallel in the cloud, and it & # x27; s important to try answer like these out before going all-in on an in-house Grid setup, so you can do allow cost-benefit analysis for your squad.

4 Parts

Connet Now