Welcome to the first in our new series, Appium + Sauce Labs Bootcamp. This first chapter will extend an overview of Appium and its command, establish with detailed examples of the Java and Python language bindings. Later we will postdate up with examples in Ruby. This series locomote from fundamental concepts to supercharge techniques using Appium and Sauce Labs. The trouble is Beginner- & gt; Advanced. In Chapter 2 discussesTouch Actions; Chapter 3 coversTesting Hybrid Apps & amp; Mobile Web; and Chapter 4 is aboutAdvanced Desired Capabilities.

The Sauce & lt; - & gt; Client Relationship

Sauce Labs provides a service consisting of two APIs which operate at different conceptual levels — the Sauce API and the Webdriver API. Both go as HTTP (fix with SSL/TLS) and encode their data as mere JSON objects:

• Commands which moderate an item-by-item Mobile Device (such as an iOS simulator or an Android copycat) are direct through the Webdriver API (urls which begin with ondemand.saucelabs.com/wd/hub).

• Commands which interact with how Sauce Labs stores Tests and Builds eg: “ Passing/Failing ” are sent through the Sauce API (urls which begin with saucelabs.com/rest/).

When running an machine-controlled tryout script, every dictation, such as tip on the screen or typing into an input field, is sent as an HTTP request to an Appium server through the Sauce Labs Webdriver API. Since commands are sent as standard HTTP packets and every language has method for communicating over the Internet, automated trial can be run and written using any programming language. Automated tryout scripts are description of scenarios that users enact when using an app and it would be cumbersome to fill them full of code which assembles HTTP packets and sends them off to specific URL. For this reason, there exist a number ofwords bindings(sometimes phoneAppium Clients or driverssince they “ drive ” a mobile device) which provide a set of methods and use which handle communication with the Appium servers running in the Sauce cloud. The Appium Java client may provide a method for pressing the HOME button:

driver.sendKeyEvent (AndroidKeyCode.HOME);

And the Appium Python client may ply a slightly different use:

driver.keyevent (3)

But both functions render the same exact HTTP packet which is sent to: ondemand.saucelabs.com/wd/hub/session/ [session Id number] /appium/device/keyevent

{
“ keycode ”: 3
}

Developers and QA specializer who write automated examination scripts take ne'er concern themselves with long URLs like the one in the example above; this is the advantage provided by the language binding. The bidding that Appium accepts are a superset of the standard protocol used by Selenium host for automating web browsers. In order to extenuate the effort of learning something completely new, the Appium language bindings all continue and modify existing Selenium language binding. Though in some cases the method are very different, the documentation for the various Selenium clients is usually applicable to the Appium customer.

Test Configuration

In order to specify the environment that Sauce Labs will set up and use for run your app, you must populate a set of & quot; trust capabilities & quot;. The total list of capabilities that Appium can understand is specifiedhere, and the set of capabilities that Sauce Labs understands is here. The three most important capableness for mobile testing on Sauce with Appium are:platformName, which fix whether you are testing an & quot; Android & quot; or & quot; iOS & quot; app;platformVersion, which let you to stipulate a specific version of the platform (e.g., iOS & quot; 7.1 & quot; or & quot; 8.0 & quot;, or Android & quot; 4.3 & quot; or & quot; 4.4 & quot;); anddeviceName, through which iOS allows you to distinguish & quot; iPhone & quot; from & quot; iPad & quot;, and for Android, allows you to specify the device itself (e.g., & quot; Samsung Galaxy S3 & quot; or & quot; Nexus 7 & quot;). Further, there are two mutually exclusive capabilities for specifying the app under test:appallows you to define the native app, and must be an app you & # x27; ve already placed in Sauce Storage or the URL of the app somewhere on the internet;browserNameis expend for mobile web testing, allowing you to get a specific browser running on the mobile device (e.g., & quot; Safari & quot; or & quot; Chrome & quot;). If you are testing a native app, donot use browserName, and vice versa. For model, to tell Sauce Labs to use the application we receive uploaded with the namemy_app.apk, and to run it on an Android ape running Android 4.4 and emulating a Samsung Galaxy S3, we use the following capabilities:

For an iOS trial, with the following capabilities we will be telling Sauce Labs to use the covering we have uploaded with the gensmy_app.app, and run it on the iPhone simulator running iOS 8.1:

The final capability in both cases pertains to Appium itself. With appiumVersion you can use a specific frame of the Appium waiter (in this case, 1.3.4, the modish as of this writing). Since the configuration of your environment can be complex and getting it right is real important, Sauce Labs provides a tool, the Platform Configurator, which allows you to visually configure the test environment you want, and give code in your desired language. Through the desired capacity you will send to Sauce Labs, you get the environment in which you would wish your examination to run. From there, you can automate your test scenarios!

Instantiating a Driver

The various Appium language bindings part the conception of providing adriverobject. When desired capableness are direct to Sauce Labs, a new environment is set up and designate asession identifier. Each driver is associated with a single session identifier and therefore each driver is associated with a individual mobile device for the duration of a test. The different language bindings experience slightly different conventions, but they all postulate to do the pursuit at the showtime of each test:

• Store the SAUCE_USERNAME and SAUCE_ACCESS_KEY for accessing the Sauce Cloud

• Set http: //ondemand.saucelabs.com:80/wd/hub as the endpoint to post Appium commands to

• Specify a set of desired capabilities for this test session

• Send the desired capabilities to Sauce Labs and begin a new session

The pursuit are samples of instantiating Appium driver in Java and Python:

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

Java

Python

Simple Commands

There are multiple commands uncommitted for the review of the elements present on the UI of a twist, and interacting with them. So many, in fact, that it can be overwhelming to learn them all at once. (The complete list is a combination of all the API endpoints delineate in theSelenium Documentation, and the Appium Documentation.) The maiden commands to learn are the following: Finding Elements

• bump element

• find constituent

Inspecting Elements

• text

• location

• size

Interacting with Elements

• click

• send_keys

These different approaches to find elements (by class gens or by accessibility ID) are calledlocator scheme. Appium has additional locator strategies for chance ingredient by id, xpath, and platform specific locator like iOS UIAutomation commands and Android UIAutomator selectors. These will be discourse in a later chapter. Inspecting Elements By inspecting the properties of elements seeable on the UI, we can discover whether or not the app conduct as await. We can test for the presence of a popup, look for a user ’ s name when logged in, see that lists are populate, that persona are in the right place, etc. Whenever a UI element is “ institute ” through appium, the server returns an id, not an object populate with UI belongings. Additional functions require to be called in order to get the specific properties of an element. The “ textbook ” command returns the textual content of the element.

String buttonText = button.getText ();

buttonText = button.text

The “ location ” bid return the current location of the element on the blind, mensurate in pixels.

Point location = button.getLocation ();

location = button.location

The “ sizing ” dictation return the size of the element on the screen, measured in pixels.

Dimension dimension = button.getSize ()

dimension = button.size

Since these property are estimate when the command is called, if the element is no longer visible on the UI the bidding will neglect. Interacting with Elements By interacting with factor, we assume the actions of a user, type into battlefield, press buttons, tapping the blind, and performing touch gestures. Use the “ click ” command to simulate tap on an factor:

button.click ();

button.click ()

Use the “ send key ” dictation to type into a text field.

textField.sendKeys (“ Hi, my name is ”);

textField.send_keys (‘ Hi, my gens is ’)

Touch gesture will be discussed in a later chapter. Discussed above are the basic command for finding, inspecting, and interacting with UI elements. The examples are in Java and Python. Each language binding follows conventions special to its developer civilisation, but they all encompass the same set of commands. When in doubt, check the documentation for a particular language binding.

Python Example