Vous êtes sur la page 1sur 17

Appium

Appium is an open source, cross-platform(Andriod, IOS and FirefoxOS) test


automation tool for native, hybrid and mobile web Apps, tested on simulators (IOS
and FirefoxOS), emulators (Andriod), and real devices (IOS, Andriod and
FireFoxOS).

Unique features:

Webdriver + Mobile Features = Appium

Inbuilt webdriver is present in Appium, its extension to webdriver.

Different types of mobile Apps: Native, Hybrid and Mobile App

Native: Pure mobile app (Specifically written in Mobile App)

Hybrid: Both native mobile view and web view

Mobile App: Use the URL using a web browser

In all the apps you can automate using Appium.

What makes Appium unique in the market?

1. You need not have to recompile the App or modify it in any way, due to use
of standard automation APIs on all platforms
2. You can use any testing framework (Junit, TestNG etc.,)
3. You can write the code in any language supported by Webdrvier
4. If you use Apples UI Automation library without Appium you can only write
tests using JavaScript and you can only run through the instruments
application. Similarly with Googles UIAutomator you can only write tests in
Java. Appium opens up the possibility of true cross-platform native mobile
automation. (Apples UI Automation API Library and Googles UIAutomator
API Library)

1
5. Common methods can be used in both Andriod and IOS this is cross-
platform feature

Internal Architecture of Appium:


Appium concepts:
Client/Server Architecture:

Appium is at its heart a webserver that exposes a REST API. It receives


connections from a client listens for commands, execute those commands on a
mobile device and responds with an HTTP response representing the result of
the command execution.

The tact that we have client/server architecture opens up a lot of possibilities


we can write out test code in any language that has a http client API, but it is
easier to use one of the Appium Client Libraries. We can put the server on a
different machine than our tests are running on.

We can write test code and rely on a cloud service like Sause Labs to receive
and interpret commands.

Session:

Automation is always performed in the context of a session. Client initiate a


session with a server in ways specific to library, but they all end up sending
post / session request to the server, with a Jason object called the desired
capabilities object. At this point the server will start up the automation
session and respond with a session ID which is used for sending further
commands.

2
Desired Capabilities:

Desired Capabilities are a set of keys and values. ( i.e., map or hash) sent to
the Appium server to tell the server what kind of automation session were
interested in standing up. There are various capabilities which can modify
the behavior of the server during automation. For example, we might set
the platformname capability to ios to tell Appium that we want an IOS
Session, rather than an Andriod one OR we might set the safariAllPopups
capability to true in order to ensure that during a Safari automation session,
were allowed to use JavaScript to open up new windows.

Appium Server:

Appium is a server written in Node.js. It can be built and installed from


source for installed directly from NPM.

Appium Clients:

There are client libraries (in Java Ruby, Python, PHP, JavaScript, and C#)
which support Appiums extensions to the WebDriver protocol when using
Appium, you want to these client libraries instead of your regular
WebDriver Client

Appium app, Appium.exe:

There exist GUI wrappers around the Appium server that can be
downloaded. These come bundled with everything required to run the
Appium Server.

JSON wire protocol (commands pass through)

Mobile
Appium Sever
Editor (Write Code) Commands 3
App
1. Client will send the commands as sessions objects which is headless
2. It send the commands through JSON wire protocol
3. Appium server acts as a proxy between Editor and Mobile App

JSON WIRE Protocol:

It will make you to write commands in any langauge.

You can write appium code in any languag - Java, Python, Ruby, PHP, C#, Perl

Commands reach the appium server as session objects - Which is headless,


independent of any language.

Appium server act as a Proxy between the mobile you are testing and client where
you actually running the code.

Appium Server have the capabilities of Andriod Framework and IOS Framwork
They have inbuild capabilities

UI Automator frame work

IOS implementation frame work

4
Appium Installation and Set Up:

1. Download Java and set Java_Home in environmenal variables

2. Download Android STUDIO from below link

3. https://developer.android.com/studio/index.html

4. Check Andriod installation path in Machine

5. Set Andriod_Home environmental variables path to SDK location

6. Open Android Studio and configure Emulator

7. Open Emulator and check if it is working

8. Download Node.js

9. https://nodejs.org/en/download/

10. Set Node_Home Enviromental variables path

11. Set npm Environmental varaiale path

12. Download Appium Server from Node

13. Download Appium Java client library

14. Install Eclipse - Create a Project in Eclipse - Configure Appium libraries

To open the AVD Emulator you can directly to it from command prompt.

1. Go to the path C:\Users\sravana\AppData\Local\Android\sdk\platform-


tools plat form tools and type avd start Demo Give the device name.
2. Then give the emulator avd Demo

Npm Node package manager it is an online repository for the publishing of


open-source Node.js projects; second, it is a command-line utility for interacting

5
with said repository that aids in package installation, version management, and
dependency management.

You can download any node module using nmp only

npm install g appium

-g means globally

Once the Appium server installed start the server using the Appium

To uninstall Appium

npm uninstall g appium

If you need a specific version

npm install g Appium@version name

Difference between Node and npm.

Node is a software In that node a command line installer called npm.

Using npm you can download any node module Appium is one node module,
Angular JS is one node module and Protractor is one node module.

1. Appium Client Appium Java Client Jar You can write code in any
language Java, C#, Ruby, Python etc.,
2. Appium Server Is a unique and listens to client code. Common across any
client.

Appium client communicates with the Appium Server and executed the test cases.

1. Class can be treated as a Test Case


2. Project can be treated as a Test Suite

Configure the JRE files in Esclipse:

6
1. Download Appium jar file Go to the site http://appium.io/downloads.html
and click on Client Libraries Lets say in our case Java
2. It will navigate to the site: https://search.maven.org/#search%7Cga
%7C1%7Cg%3Aio.appium%20a%3 Ajava-client
3. Click on jar under download column
4. Then go to http://www.seleniumhq.org/download/ and download the
Selenium Client & Webdriver language bindings for Java language
5. Open eclipse right click on Project folder and go to properties go to Java
build path and libraries and get the jars for Appium and Selenium.

You are ready to start the Appium code for mobile app testing using java
language.

Appium on MAC:

Installing XCode A set of development software tools Its an IDE. You Can
write and develop Apps. Xcode you can get it from AppStore

Checking for IOS simulator Version in Xcode

Installing Java

Installing Eclipse

Downloading Appium Servers/Jars

Prerequisites:

1. Make sure your Appium server is started


2. Ensure what emulator you are going to work and its opened

First Appium Program:

I want to open android emulator Demo.

You can use Desired Capabilities

7
You can test an app in emulator. Install the app in emulator and has to be
tested.

A connection step is required to connect the server.

1. Open emulator
2. Invoke App
3. Connect to server

Android application package file (APK) is the file format used to distribute and
install application software and middleware onto Google's Android operating
system. APK files are ZIP file formatted packages based on the JAR file format,
with .apk file extensions.

How to invoke or install App in emulator using APK file:

1. First download or get the apk file from devevloper.


2. Copy the file and paste it in project src folder in eclipse.
3. Once it is pasted run the below code by changing the apk file accordingly.

import org.openqa.selenium.remote.DesiredCapabilities;

import io.appium.java_client.android.AndroidDriver;

import io.appium.java_client.android.AndroidElement;

import io.appium.java_client.remote.MobileCapabilityType;

public class Ribase {

public static void main(String[] args) throws


MalformedURLException {

8
// TODO Auto-generated method stub

File fi=new File("src");

File fil=new File(fi,"com.raaga.android_3.0.1.apk");

DesiredCapabilities capbs=new DesiredCapabilities();

capbs.setCapability(MobileCapabilityType.DEVICE_NAME,
"Demo");

capbs.setCapability(MobileCapabilityType.APP,
fil.getAbsolutePath());

AndroidDriver<AndroidElement> driver = new


AndroidDriver<>(new URL("http://127.0.0.1:4723/wd/hub"), capbs);

Connection and Session:

Session takes 60 seconds to close.

import java.io.File;
import java.net.MalformedURLException;

9
import java.net.URL;
import java.util.concurrent.TimeUnit;

import org.openqa.selenium.remote.DesiredCapabilities;

import io.appium.java_client.android.AndroidDriver;
import io.appium.java_client.android.AndroidElement;
import io.appium.java_client.remote.MobileCapabilityType;

public class base {


public static AndroidDriver<AndroidElement> capabilities() throws
MalformedURLException
{

AndroidDriver<AndroidElement> driver;

// TODO Auto-generated method stub


File appDir = new File("src");
File app = new File(appDir, "ApiDemos-debug.apk");
DesiredCapabilities capabilities = new DesiredCapabilities();

capabilities.setCapability(MobileCapabilityType.DEVICE_NAME,
"Rahulemulator");
capabilities.setCapability(MobileCapabilityType.APP, app.getAbsolutePath());
driver = new AndroidDriver<>(new URL("http://127.0.0.1:4723/wd/hub"),
capabilities);

return driver;
}

Andriod UI Automater:

Using these tools we can get the objects and the properties.

C:\Users\sravana\AppData\Local\Android\sdk\tools\bin

10
Go to this path, you find the UI Automator and click on UI Automator

The best locators for Mobile automation:

Xpath, id, class name, accessibility id, -android UIAutomator

Xpath Syntax:

//tagname[@attribute=value]

Core attributes it identify an object in mobile automation:

1. Index

2. text

3. resource-id

4. class

5. package

Text is unique attribute you can use to identify object.

Android Activities Mobile specific methods

driver.currentActivity The page activity

driver.getContext() This gives whether you are in Hybrid App, Native App or

Web App/Web View

driver.getOreientation Landscape and Portrait

driver.isLocked Check the mobile is locked or not

driver.hideKeyboard To hide the keyboard

11
To go back to Home page or to go back to the previous page in Android Mobile,
we need to use the below code:

driver.pressKeyCode(AndroidKeyCode.BACK)

driver.pressKeyCode(AndriodKeyCode.HOME)

Interview Question:

How do you operate keyword events using Appium?

Using pressKeyCode

Testing the App in Mobile Real device or Emulator:

1. Get the .apk file and test it

2. Do not have the .apk file

If you do not have the .apk file.

1. With the help of commands bring out the .apk file

2. If you know the app package and main activity of the app. With the help of
these two we can invoke the app without need of .apk file

Example

First you need to know the package name of that App. Every App has
unique package name.

Second you need to know the Main Activity. Each page has an activity and
defined as an activity.

The first page is the main launch activity.

12
Real Device Testing

According to industry experts like Gartner, you will get the most out of your
testing automation if you include a healthy mix of emulators, simulators, and real
devices as your mobile testing platforms. Why? Because there are aspects of the
mobile experience that you can't test on an emulator or simulator, like location-
based applications that use manufacture specific device sensors, memory
consumption, and CPU usage. There are a variety of use cases to consider when
you're deciding on the mix of emulators/simulators/real devices that you want to
use in your testing.

When to Test on Real Devices When to Test on


Emulators/Simulators

Need breadth of device types for Need massive concurrency


panel/compatibility testing Want to reduce build times

13
Need to replicate an issue to match Want to save costs
exact model as reported Need immediate availability
Need pixel perfect display testing Require extremely low error
Need to test hardware rates for your test environment
dependencies like CPU, memory, display,
GPS, etc.
Need to test native ARM Libraries
Need to test on a custom OS (for
example, Samsung TouchWiz, OnePlus
OxygenOS, etc.)

Need to test on a native frameworks


like Espresso and Robotium

To test on a real device:

Code:

Public void test() throws MalformedURLException{

File appDir = new File(src);

File app = new File(appDir, booMyShow-ucb.apk);

DesiredCapabilities cap=new DesiredCapabilities();

cap.setCapability(MobileCapabilityType.PLATFORM_NAME,MobilePlatform.ANDR
OID);

14
cap.setCapability(MobileCapabilityType.DEVICE_NAME, Android Emulator);

// For real devices you need to change the Emulator Text to Device(check below)

cap.setCapability(MobileCapabilityType.DEVICE_NAME, Android Device);

cap.setCapability(MobileCapabilityType.NEW_COMMAND_TIMEOUT, 100);

cap.setCapability(MobileCapabilityType. APP, app.getObsolutePath());

How do you cross check the anroid devices are connected to our system or not?

To identify objects in Appium we can use a


findElementByAndroidUIAutomator by directly giving the attribute name
and value

Example: //Validate clickable features for all options

System.out.println(driver.findElementsByAndroidUIAutomator("new
UiSelector().clickable(true)").size());

Another feature that you wanted to verify the properties and the values like
Clickable, Checked, Enabled, Focused, Checkable etc., to check their values
for all the objects at a time, you can use new UiSelector()

15
//Validate clickable features for all options
System.out.println(driver.findElementsByAndroidUIAutomator("new
UiSelector().clickable(true)").size());

Android Gestures:

To capture the actions of android gestures like zoom in, zoom out, tap, drag etc.,

You can use TouchAction Class

TouchAction t = new TouchAction(driver);

The important gestures in Android and Appium are Tap, Press, Release, Swipe,
drag and drop.

Note:

In x-path tag ifable to it contains any special characters like $ or @ or & it will not
consider and not able to identify the object or element. So you have to use the
regular expression in order to use the Xpath.

Ex: Attribute Class : Value is


android.widget.RadialTimePickerView$RadialPickerTouchHelper

If you see the above tag, it contains $ symbol. So xpath is not valid.

Here you have to use the xpath as, means use * as a regular expression.

16
//*[@text=View]

To Scroll in emulator you have to use the below method:

driver.findElementsByAndroidUIAutomator("new UiScrollable(new
UiSelector()).scrollIntoView(text(\"WebView\"));");

17