Search icon
Subscription
0
Cart icon
Close icon
You have no products in your basket yet
Save more on your purchases!
Savings automatically calculated. No voucher code required
Arrow left icon
All Products
Best Sellers
New Releases
Books
Videos
Audiobooks
Learning Hub
Newsletters
Free Learning
Arrow right icon
$9.99 | ALL EBOOKS & VIDEOS
Over 7,000 tech titles at $9.99 each with AI-powered learning assistants on new releases
Appium Essentials
Appium Essentials

Appium Essentials: Explore mobile automation with Appium and discover new ways to test native, web, and hybrid applications

$25.99 $9.99
Book Apr 2015 188 pages 1st Edition
eBook
$25.99 $9.99
Print
$32.99
Subscription
$15.99 Monthly
eBook
$25.99 $9.99
Print
$32.99
Subscription
$15.99 Monthly

What do you get with eBook?

Product feature icon Instant access to your Digital eBook purchase
Product feature icon Download this book in EPUB and PDF formats
Product feature icon Access this title in our online reader with advanced features
Product feature icon DRM FREE - Read whenever, wherever and however you want
Buy Now

Product Details


Publication date : Apr 9, 2015
Length 188 pages
Edition : 1st Edition
Language : English
ISBN-13 : 9781784392482
Table of content icon View table of contents Preview book icon Preview Book

Appium Essentials

Chapter 1. Appium – Important Conceptual Background

In this chapter, we will learn about the Appium architecture, JavaScript Object Notation (JSON) wire protocol, and Appium sessions as well as gain an understanding of the desired capabilities before starting Appium. This chapter will also touch upon the topics of the Appium server and its client library.

In short, we will cover the following topics:

  • Appium's architecture

  • The Selenium JSON wire protocol

  • Appium sessions

  • Desired capabilities

  • The Appium server and its client library

Appium architecture


Appium is an HTTP server written in Node.js that creates and handles WebDriver sessions. The Appium web server follows the same approach as the Selenium WebDriver, which receives HTTP requests from client libraries through JSON and then handles those requests in different ways, depending on the platform it is running on.

Let's discuss how Appium works in iOS and Android.

Appium on iOS

On an iOS device, Appium uses Apple's UIAutomation API to interact with the UI elements. UIAutomation is a JavaScript library provided by Apple to write test scripts; Appium utilizes these same libraries to automate iOS apps.

Let's take a look at the architecture, which is shown in the following diagram:

In the preceding diagram, when we execute the test scripts, it goes in the form of JSON through an HTTP request to the Appium server. The Appium server sends the command to the instruments, and the instruments look for the bootstrap.js file, which is pushed by the Appium server to the iOS device. Then, these commands execute in the bootstrap.js file within the iOS instruments' environment. After the execution of the command, the client sends back the message to the Appium server with the log details of the executed command.

A similar kind of architecture follows in the case of Android app automation. Let's discuss the Appium architecture for Android.

Appium on Android

On an Android device, Appium uses the UIAutomator framework to automate the apps. UIAutomator is a framework that is developed by the Android developers to test the Android user interface.

Let's take a look at the architecture, which is shown in the following diagram:

In the preceding diagram, we have a UIAutomator/Selendroid in place of Apple instruments and bootstrap.jar in place of the bootstrap.js file.

Appium supports Android versions greater than or equal to 17; for earlier versions, it uses the Selendroid framework. When we execute the test scripts, Appium sends the command to the UIAutomator or Selendroid on the basis of the Android version.

Here, bootstrap.jar plays the role of a TCP server, which we can use to send the test command in order to perform the action on the Android device using UIAutomator/Selendroid.

The Selenium JSON wire protocol


The JSON wire protocol (JSONWP) is a transport mechanism created by WebDriver developers. This wire protocol is a specific set of predefined, standardized endpoints exposed via a RESTful API. The purpose of WebDriver and JSONWP is the automated testing of websites via a browser such as Firefox driver, IE driver, and Chrome driver.

Appium implements the Mobile JSONWP, the extension to the Selenium JSONWP, and it controls the different mobile device behaviors, such as installing/uninstalling apps over the session.

Let's have a look at some of the endpoints from the API which are used to interact with mobile applications:

  • /session/:sessionId

  • /session/:sessionId/element

  • /session/:sessionId/elements

  • /session/:sessionId/element/:id/click

  • /session/:sessionId/source

  • /session/:sessionId/url

  • /session/:sessionId/timeouts/implicit_wait

Appium provides client libraries similar to WebDriver that act as an interface to the REST API. These libraries have functions similar to the following method:

AppiumDriver.getPageSource();

This method will issue an HTTP request to the JSONWP, and it gets the response from the applicable API endpoint. In this case, the API endpoint that handles the getPageSource method is as follows:

/session/:sessionId/source

The driver will execute the test script that comes in the JSON format from the AppiumDriver server to get the source. It will return the page source in the string format. In case of non-HTML (native mobile apps) platforms, the Appium library will respond with an XML document representation of the UI hierarchy. The specific structure of the document may vary from platform to platform.

Appium session


A session is a medium to send commands to the specific test application; a command is always performed in the context of a session. As we saw in the previous section, a client uses the session identifier as the sessionId parameter before performing any command. The client library requests the server to create a session. The server will then respond with a sessionId endpoint, which is used to send more commands to interact with the application(s) being tested.

Desired capabilities


Desired capabilities is a JSON object (a set of keys and values) sent by the client to the server. It describes the capabilities for the automation session in which we are interested.

Let's discuss the capabilities one by one; first, we will see the Appium server's capabilities:

We need to import "import org.openqa.Selenium.remote.DesiredCapabilities" library for Java to work with the desired capabilities.

Capability

Explanation

automationName

This capability is used to define the automation engine. If you want to work with an Android SDK version less than 17, then you need to define the value as Selendroid; otherwise, the capability takes the default value as Appium. Let's see how we can implement it practically:

DesiredCapabilities caps = new DesiredCapabilities(); // creating an object
caps.setCapability("automationName","Selendroid");
// to set capability value

We can also set the capabilities using Appium's client library. For this, users need to import "import io.appium.java_client.remote.MobileCapabilityType" library:

caps.setCapability(MobileCapabilityType.AUTOMATION_NAME,"Selendroid");

There's no need to use this capability in the case of iOS.

platformName

It is used to set the mobile OS platform. It uses the value as iOS, Android, or FirefoxOS:

caps.setCapability("platformName","Android");

In case of the Appium client library, you can use this:

caps.setCapability(MobileCapabilityType.PLATFORM_NAME, "Android");

platformVersion

To set the mobile OS version, for example, 7.1, 4.4.4, use the following command:

caps.setCapability("platformVersion","4.4.4");

Alternatively, you can use the following command as well:

caps.setCapability(MobileCapabilityType.PLATFORM_VERSION, "4.4.4");

deviceName

We can define the type of mobile device or emulator to use, using the following command, for example, iPhone Simulator, iPad Simulator, iPhone Retina 4-inch, Android Emulator, Moto x, Nexus 5, and so on:

caps.setCapability("deviceName", "Nexus 5");

You can use the following command as well:

caps.setCapability(MobileCapabilityType.DEVICE_NAME,"Nexus 5");

app

We can add the absolute local path or remote HTTP URL of the .ipa,.apk, or .zip file. Appium will install the app binary on the appropriate device first. Note that in the case of Android, if you specify the appPackage and appActivity (both the capabilities will be discussed later in this section) capabilities, then this capability shown here is not required:

caps.setCapability("app","/apps/demo/demo.apk or http://app.com/app.ipa");

Alternatively, you can use the following command:

caps.setCapability(MobileCapabilityType.APP,"/apps/demo/demo.apk or http://app.com/app.ipa");

browserName

If you want to automate mobile web applications, then you have to use this capability to define the browser.

For Safari on iOS, you can use this:

caps.setCapability("browserName", "Safari");

Also, you can use the following command:

caps.setCapability(MobileCapabilityType.BROWSER_NAME, "Safari");

For Chrome on Android, you can use this:

caps.setCapability("browserName", "Chrome");

Alternatively, you can use the following command:

caps.setCapability(MobileCapabilityType.BROWSER_NAME, "Chrome");

newCommandTimeout

To end the session, Appium will wait for a few seconds for a new command from the client before assuming that the client quit. The default value is 60. To set this time, you can use the following command:

caps.setCapability("newCommandTimeout", "30");

You can also use this command to end the session:

caps.setCapability(MobileCapabilityType.NEW_COMMAND_TIMEOUT,"30");

autoLaunch

This capability is used to install and launch the app automatically. The default value is set to true. You can set the capability with the following command:

caps.setCapability("autoLaunch","false");

language

This is used to set the language on the simulator/emulator, for example, fr, es, and so on. The following command will work only on the simulator/emulator:

caps.setCapability("language","fr");

locale

This is used to set the locale for the simulator/emulator, for example, fr_CA, tr_TR, and so on:

caps.setCapability("locale","fr_CA");

udid

A unique device identifier (udid) is basically used to identify iOS physical device. It is a 40 character long value (for example, 1be204387fc072g1be204387fc072g4387fc072g). This capability is used when you are automating apps on iOS physical device. We can easily get the device udid from iTunes, by clicking on Serial Number:

caps.setCapability("udid", "1be204387fc072g1be204387fc072g4387fc072g");

orientation

This is used to start in a certain orientation in simulator/emulator only, for example, LANDSCAPE or PORTRAIT:

caps.setCapability("orientation", "PORTRAIT");

autoWebview

If you are automating hybrid apps and want to move directly into the Webview context, then you can set it by using this capability; the default value is false:

caps.setCapability("autoWebview", "true");

noReset

This capability is used to reset the app's state before the session starts; the default value is false:

caps.setCapability("noReset"-," true");

fullReset

In iOS, this will delete the entire simulator folder. In Android, you can reset the app's state by uninstalling the app instead of clearing the app data; also, it will remove the app after the session is complete. The default value is false. The following is the command for fullReset:

caps.setCapability("fullReset", "true");

Android capabilities

Now, let's discuss the Android capabilities, as shown in the following table:

Capability

Explanation

appPackage

This capability is for the Java package of the Android app that you want to run, for example, com.android.calculator2, com.android.settings, and so on:

caps.setCapability("appPackage", "com.android.calculator2");

Alternatively, you can use this command:

caps.setCapability(MobileCapabilityType.APP_PACKAGE, "com.android.calculator2");

appActivity

By using this capability, you can specify the Android activity that you want to launch from your package, for example, MainActivity, .Settings, com.android.calculator2.Calculator, and so on:

caps.setCapability("appActivity", "com.android.calculator2.Calculator");

You can also use the following command:

caps.setCapability(MobileCapabilityType.APP_ACTIVITY, "com.android.calculator2.Calculator");

appWaitActivity

Android activity for which the user wants to wait can be defined using this capability:

caps.setCapability("appWaitActivity","com.android.calculator2.Calculator");

Alternatively, you can also use this command:

caps.setCapability(MobileCapabilityType.APP_WAIT_ACTIVITY,"com.android.calculator2.Calculator");

appWaitPackage

The Java package of the Android app you want to wait for can be defined using the following capability, for example, com.example.android.myApp, com.android.settings, and so on:

caps.setCapability("appWaitPackage","com.example.android.myApp");

deviceReadyTimeout

You can set the timeout (in seconds) while waiting for the device to be ready, as follows; the default value is 5 seconds:

caps.setCapability("deviceReadyTimeout","10");

Alternatively, you can also use this command:

caps.setCapability(MobileCapabilityType.DEVICE_READY_TIMEOUT,"10");

enablePerformanceLogging

You can enable the Chrome driver's performance logging by the use of this capability. It will enable logging only for Chrome and web view; the default value is false:

caps.setCapability("enablePerformanceLogging", "true");

androidDeviceReadyTimeout

To set the timeout in seconds for a device to become ready after booting, you can use the following capability:

caps.setCapability("androidDeviceReadyTimeout","20");

androidDeviceSocket

This capability is used to set DevTools socket name. It is only needed when an app is a Chromium-embedding browser. The socket is opened by the browser and the ChromeDriver connects to it as a DevTools client, for example, chrome_DevTools_remote:

caps.setCapability("androidDeviceSocket","chrome_DevTools_remote");

Avd

Using this capability, you can specify the name of avd that you want to launch, for example, AVD_NEXUS_5:

caps.setCapability("avd","AVD_NEXUS_5");

avdLaunchTimeout

This capability will help you define how long you need to wait (in milliseconds) for an avd to launch and connect to the Android Debug Bridge (ADB) (the default value is 120000):

caps.setCapability("avdLaunchTimeout","230000");

avdReadyTimeout

You can specify the wait time (in milliseconds) for an avd to finish its boot animations using the following capability; the default wait timeout is 120000:

caps.setCapability("avdReadyTimeout","240000");

avdArgs

To pass the additional emulator arguments when launching an avd, use the following capability, for example, netfast:

caps.setCapability("avdArgs","netfast");

chromedriverExecutable

You can give the absolute local path to the WebDriver executable (if the Chromium embedder provides its own WebDriver, it should be used instead of the original ChromeDriver bundled with Appium) using the following capability:

caps.setCapability("chromedriverExecutable","/abs/path/to/webdriver");

autoWebviewTimeout

The following capability allows you to set the time (in milliseconds) for which you need to wait for the Webview context to become active; the default value is 2000:

caps.setCapability("autoWebviewTimeout","3000");

intentAction

Intent action is basically used to start an activity, as shown in the following code. The default value is android.intent.action.MAIN. For example, android.intent.action.MAIN, android.intent.action.VIEW, and so on:

caps.setCapability("intentAction","android.intent.action.VIEW");

intentCategory

This provides the intent category that will be used to start the activity (the default is android.intent.category.LAUNCHER), for example, android.intent.category.LAUNCHER, android.intent.category.APP_CONTACTS:

caps.setCapability("intentCategory","android.intent.category.APP_CONTACTS");

intentFlags

Flags are used to start an activity (the default is 0x10200000), for example, 0x10200000:

caps.setCapability("intentFlags","0x10200000");

unicodeKeyboard

You can enable Unicode input by using the following code; the default value is false:

caps.setCapability("unicodeKeyboard","true");

resetKeyboard

You can reset the keyboard to its original state by using this capability. The default value is false:

caps.setCapability("resetKeyboard","true");

iOS capabilities

Let's discuss the iOS capabilities, as shown in the following table:

Capability

Explanation

calendarFormat

This is used to set the calendar format for the iOS simulator. It applies only to a simulator, for example, Gregorian:

caps.setCapability("calendarFormat"," Gregorian");

bundleId

BundleId is basically used to start an app on a real device or to use other apps that require the bundleId during the test startup, for example, io.appium.TestApp:

caps.setCapability("bundleId"," io.appium.TestApp");

launchTimeout

This is used to specify the amount of time (in millisecond) you need to wait for Instruments before assuming that it hung and the session failed. This can be done using the following command:

caps.setCapability("launchTimeout","30000");

locationServicesEnabled

This capability is used to enable location services. You can apply it only on a simulator; you can give the Boolean value, as follows:

caps.setCapability("locationServicesEnabled","false");

locationServicesAuthorized

If you want to use this capability, you must provide the bundleId by using the bundleId capability. You can use this capability on a simulator. After setting this, the location services alert doesn't pop up. The default is the current simulator setting and its value is false:

caps.setCapability("locationServicesAuthorized","true");

autoAcceptAlerts

Using this capability, you can accept privacy permission alerts automatically, such as location, contacts, photos, and so on, if they arise; the default value is false:

caps.setCapability("autoAcceptAlerts","true");

nativeInstrumentsLib

You can use the native instruments library by setting up this capability:

caps.setCapability("nativeInstrumentsLib","true");

nativeWebTap

This can be used to enable real web taps in Safari, which are non-JavaScript based. The default value is false. Let me warn you that this might not perfectly deal with an element; it depends on the viewport's size/ratio:

caps.setCapability("nativeWebTap","false");

safariAllowPopups

You can use this capability on a simulator only. It allows JavaScript to open new windows in Safari. The default is the current simulator setting. To do this, you can use the following command:

caps.setCapability("safariAllowPopups","false");

safariIgnoreFraudWarning

This capability can be used only on a simulator. It prohibits Safari from displaying a fraudulent website warning. The default value is the current simulator setting, as follows:

caps.setCapability("safariIgnoreFraudWarning","false");

safariOpenLinksInBackground

This capability enables Safari to open links in new windows; the default keeps the current simulator settings:

caps.setCapability("safariOpenLinksInBackground","true");

keepKeyChains

Whether you need to keep keychains (Library/Keychains) when an Appium session is started/finished can be defined using this capability. You can apply it on a simulator, as follows:

caps.setCapability("keepKeyChains","true");

processArguments

This capability allows you to pass arguments while AUT using instruments, for example, myflag:

caps.setCapability("processArguments","myflag");

interKeyDelay

You can delay the keystrokes sent to an element when typing uses this capability. It takes the value in milliseconds:

caps.setCapability("interKeyDelay","100");

We have seen all the desired capabilities that are used in Appium. Now, we will talk in brief about the Appium server and its client library.

The Appium server and its client libraries


The Appium server is used to interact with different platforms such as iOS and Android. It creates a session to interact with mobile apps, which are not supported on any platform. It is an HTTP server written in Node.js and uses the same concept as the Selenium Server, which identifies the HTTP requests from the client libraries and sends these requests to the appropriate platform. To start the Appium server, users need to download the source or install it directly from npm. Appium also provides the GUI version of the server. You can download it from the official Appium site, http://appium.io. In the next chapter, we will discuss the GUI version in more detail.

One of the biggest advantages of Appium is because it is simply a REST API at its core, the code you use to interact with it is written in a number of languages such as Java, C#, Ruby, Python, and others. Appium extends the WebDriver client libraries and adds the extra commands in it to work with mobile devices. It provides client libraries that support Appium extensions to the WebDriver protocol. Because of these extensions to the protocol, it is important to use Appium-specific client libraries to write automation tests or procedures, instead of generic WebDriver client libraries.

Appium added some interesting functionality for working closely with mobile devices, such as multitouch gestures and screen orientation. We will see the practical implementation of these functionalities later.

Summary


We should now have an understanding of the Appium architecture, JSON wire protocol, desired capabilities, and its uses. We also learned about the Appium server and its language-specific client library in this chapter.

Specifically, we dove into JSONWP and Appium session, which are used to send further commands in order to interact with the application. We also set up automation sessions using the desired capabilities. In the last section, we grasped some information about the Appium server and its language-specific client libraries.

In the next chapter, we will take a look at what we require to get started with Appium.

Left arrow icon Right arrow icon

Key benefits

What you will learn

Understand the desired capabilities that need to be acquired before starting Appium Get to know and use the settings that are required to automate mobile applications Interact with mobile applications by identifying elements using different locator strategies and techniques Install mobile apps onto an emulator/simulator or a real device using Appium scripts Test scripts written to automate applications Configure mobile devices and perform automation testing on them Explore the advanced features of Appium such as scroll, zoom, and swipe

What do you get with eBook?

Product feature icon Instant access to your Digital eBook purchase
Product feature icon Download this book in EPUB and PDF formats
Product feature icon Access this title in our online reader with advanced features
Product feature icon DRM FREE - Read whenever, wherever and however you want
Buy Now

Product Details


Publication date : Apr 9, 2015
Length 188 pages
Edition : 1st Edition
Language : English
ISBN-13 : 9781784392482

Table of Contents

14 Chapters
Appium Essentials Chevron down icon Chevron up icon
Credits Chevron down icon Chevron up icon
About the Author Chevron down icon Chevron up icon
About the Reviewers Chevron down icon Chevron up icon
www.PacktPub.com Chevron down icon Chevron up icon
Preface Chevron down icon Chevron up icon
1. Appium – Important Conceptual Background Chevron down icon Chevron up icon
2. Getting Started with Appium Chevron down icon Chevron up icon
3. The Appium GUI Chevron down icon Chevron up icon
4. Finding Elements with Different Locators Chevron down icon Chevron up icon
5. Working with Appium Chevron down icon Chevron up icon
6. Driving Appium on Real Devices Chevron down icon Chevron up icon
7. Advanced User Interactions Chevron down icon Chevron up icon
Index Chevron down icon Chevron up icon

Customer reviews

Filter icon Filter
Top Reviews
Rating distribution
Empty star icon Empty star icon Empty star icon Empty star icon Empty star icon 0
(0 Ratings)
5 star 0%
4 star 0%
3 star 0%
2 star 0%
1 star 0%

Filter reviews by


No reviews found
Get free access to Packt library with over 7500+ books and video courses for 7 days!
Start Free Trial

FAQs

How do I buy and download an eBook? Chevron down icon Chevron up icon

Where there is an eBook version of a title available, you can buy it from the book details for that title. Add either the standalone eBook or the eBook and print book bundle to your shopping cart. Your eBook will show in your cart as a product on its own. After completing checkout and payment in the normal way, you will receive your receipt on the screen containing a link to a personalised PDF download file. This link will remain active for 30 days. You can download backup copies of the file by logging in to your account at any time.

If you already have Adobe reader installed, then clicking on the link will download and open the PDF file directly. If you don't, then save the PDF file on your machine and download the Reader to view it.

Please Note: Packt eBooks are non-returnable and non-refundable.

Packt eBook and Licensing When you buy an eBook from Packt Publishing, completing your purchase means you accept the terms of our licence agreement. Please read the full text of the agreement. In it we have tried to balance the need for the ebook to be usable for you the reader with our needs to protect the rights of us as Publishers and of our authors. In summary, the agreement says:

  • You may make copies of your eBook for your own use onto any machine
  • You may not pass copies of the eBook on to anyone else
How can I make a purchase on your website? Chevron down icon Chevron up icon

If you want to purchase a video course, eBook or Bundle (Print+eBook) please follow below steps:

  1. Register on our website using your email address and the password.
  2. Search for the title by name or ISBN using the search option.
  3. Select the title you want to purchase.
  4. Choose the format you wish to purchase the title in; if you order the Print Book, you get a free eBook copy of the same title. 
  5. Proceed with the checkout process (payment to be made using Credit Card, Debit Cart, or PayPal)
Where can I access support around an eBook? Chevron down icon Chevron up icon
  • If you experience a problem with using or installing Adobe Reader, the contact Adobe directly.
  • To view the errata for the book, see www.packtpub.com/support and view the pages for the title you have.
  • To view your account details or to download a new copy of the book go to www.packtpub.com/account
  • To contact us directly if a problem is not resolved, use www.packtpub.com/contact-us
What eBook formats do Packt support? Chevron down icon Chevron up icon

Our eBooks are currently available in a variety of formats such as PDF and ePubs. In the future, this may well change with trends and development in technology, but please note that our PDFs are not Adobe eBook Reader format, which has greater restrictions on security.

You will need to use Adobe Reader v9 or later in order to read Packt's PDF eBooks.

What are the benefits of eBooks? Chevron down icon Chevron up icon
  • You can get the information you need immediately
  • You can easily take them with you on a laptop
  • You can download them an unlimited number of times
  • You can print them out
  • They are copy-paste enabled
  • They are searchable
  • There is no password protection
  • They are lower price than print
  • They save resources and space
What is an eBook? Chevron down icon Chevron up icon

Packt eBooks are a complete electronic version of the print edition, available in PDF and ePub formats. Every piece of content down to the page numbering is the same. Because we save the costs of printing and shipping the book to you, we are able to offer eBooks at a lower cost than print editions.

When you have purchased an eBook, simply login to your account and click on the link in Your Download Area. We recommend you saving the file to your hard drive before opening it.

For optimal viewing of our eBooks, we recommend you download and install the free Adobe Reader version 9.