Mockito vs JMockit

A Brief analysis on Mockito And Jmockit

Mockito	JMockit
1. We can achieve Static method/constructor mocking by the combination of Mockito with Powermock.

Read More

Unit tests with jmockit

What is JMockit?

JMockit is open source software unit testing library, It includes APIs for mocking, faking, and combining with a code coverage tool. This library is used together with a testing framework such as JUnit or TestNG.  IntelliJ IDEA is a good ide for testing with JMockit.

Read More

Appium tutorial for beginners (Android on windows 10 OR ubuntu)

What is Appium?

Appium is an open source test automation tool developed and supported by Sauce Labs to automate native and hybrid mobile apps. It is basically know as a Cross-browser Mobile Automation Tool. It uses JSON wire protocol internally to interact with iOS and Android native apps using the Selenium WebDriver.

Appium Architecture

Appium is a HTTP server written in node.js which creates and handles multiple WebDriver sessions for different platforms like iOS and Android.

Appium starts a “test case” on the device that spawns a server and listens for proxies commands from the main Appium server. It is almost same as Selenium server which perceives HTTP requests from selenium client libraries and it handles those requests in different ways depending upon the platforms. Each vendor like iOS and Android have a different way and mechanism to run a test case on the device so Appium kind of hacks in to it and run this testcase after listening commands fromAppium server.

How Appium works in iOS?

On iOS, Appium proxies command to a UIAutomation script running in Mac Instruments environment. Apple provides this application called ‘instruments’ which is used to do lot activities like profiling, controlling and building iOS apps but it also has an automation component where we can write some commands in javascript which uses UIAutomation APIs to interact with the App UI.Appium utilizes these same libraries to automate iOS Apps.

In the above figure, we can see the architecture of the Appium in context to the iOS automation. If we talk about a command life-cycle, it goes like, Selenium webdriver picks a command form the code like (Element.click) and sends it in form of JSon via http request to the Appium server.  Appium server knows the automation context like the iOS and Android and sends this command to the Instruments command server which will wait for the Instruments command client (written in node.js) to pick it up and execute it in bootstrap.js with in the iOS instruments environment. Once the command is executed the command client sends back the message to the Appium server which logs everything related to the command in its console. This cycle keeps going till the time all the commands gets executed.

How Appium works in Android?

The situation is almost similar in case of Android where Appium proxies commands to a UIAutomator test case running on the device. UIAutomator is Android’s native UI automation framework which supports running junit test cases directly in to the device from the command line.It uses java as a programming language but Appium will make it run from any of the WebDriversupported languages.

In the above diagram we can see, here we have Bootstrap.jar in place of bootstrap.js which represents out test case when compiled in java. As soon as it gets launched it spawns a TCP server. Here the TCP server resides inside the device and client is in the Appium process which is just opposite to the way it is in iOS.

Appium’s Pros and Cons:

Pros:

• The beauty of Appium is that, all the complexities are under the hood of Appium server and for an automation developer the programming language and the whole experience would remain same irrespective of the platform he is automating (iOS or Android).
• The other benefits of Appium is that it opens the door to cross-platform mobile testing which means the same test would work on multiple platforms.
• Unlike other tools Appium doesn’t require you to include some extra agents in your app to make it automation friendly. It believes in the philosophy of testing the same app which we are going to submit in the app store.
• It is developed and supported by Sauce Labs and it is getting picked really fast with in theWebDriver community for mobile automation.
• It can automate Web, Hybrid and Native mobile applications.

Cons:

• Scaling up is an important consideration with Continuous Integration and Appium comes across as a great tool to fulfill this expectation. The reason for this is a technical limitation, in iOS we can only run one instance on Instruments per Mac OS so we can only run our iOS scripts on one device per mac machine. So if we want to run our tests on multiple iOS devices at the same time then we would need to arrange the same number of Mac machines, which would be costly affair. But this limitation can be resolved if we execute our scripts in Sauce Lab’s mobile cloud which at present supports running scripts on multiple iOS simulators at the same time.
• Appium uses UIAutomator for Android automation which only supports Android SDK Platform, API 16 or higher so to support the older APIs they have used another open source library called Selendroid. So I would not say it as a limitation but it is definitely an overhead on the configuration side.

To Configure Appium on Mac:

Following configurations are required to run Appium on Mac:

• First we need to download the Appium app for Mac from this link. Once downloaded you need to move this app in to your applications folder and then you can launch it from your Mac Launchpad.
• As Appium uses node.js internally so we would also need to install node on the mac machine, which can be downloaded from http://nodejs.org/ , it will download a node-v0.10.xx.pkg file which you need to install.
• We also need to make sure we are using Mac OSX 10.7+
• XCode 4.5 or higher version along with iPhone simulator SDK and Command Line Tools should be installed on the mac machine.

Set up Appium with Eclipse

Introduction

Step 1: Install the Java Development Kit (JDK)

Step 2: Set Up Java Environment Variable Path

Step 3: Install Android SDK / ADB on Windows

Step 4: Set up Android Environment Variable

Step 5: Download and Install NodeJs

Step 6: Install Microsoft .net Framework

Step 7: Download And Install Appium Desktop Client

Step 8: Enabling Developer Mode Options on Android Phone or Tablet

Step 9: Install PdaNet to Connect with Android Device

Step 10: Install Eclipse IDE And Set up a Project

Step 11: Set Up Appium Project in Eclipse

Step 12: First Appium Test to Launch Amazon App

Appium Basics

Chapter 1: How to use Appium UIAutomatorViewer

Chapter 2: How to use Locators in Appium

Chapter 3: Inspect elements of Mobile Web Application

Chapter 4: How to Inspect and Automate WebView in Hybrid App

-----

Things to Know

Topic 1: How to find aapPackage & aapActivity

Topic 2: How to transfer APK file from Phone to PC

Topic 3: ADB Commands

Setting Up Virtual Devices

Topic 1: How to Create an Android Virtual Device using Android Emulator

Topic 2: Creating Custom Device Definition Using AVD Manager

Set up Appium with Eclipse in detail: Run The First Test

Now you are all set to write your first test script. Create a small test Program for opening a Amazon application on your device using Appium (Here, I use emulator on ubuntu 14.04).

1) Copy & paste the below code to your StartApplication class and give it a run.

package amazon;

import io.appium.java_client.android.AndroidDriver;
import java.io.File;
import java.net.MalformedURLException;
import java.net.URL;
import java.util.concurrent.TimeUnit;
import org.openqa.selenium.remote.CapabilityType;
import org.openqa.selenium.remote.DesiredCapabilities;

public class StartApplication {

private static AndroidDriver driver;
public static void main(String[] args) throws MalformedURLException, InterruptedException {

File classpathRoot = new File(System.getProperty("user.dir"));
File appDir = new File(classpathRoot, "/Apps/Amazon/");
//System.out.println(classpathRoot.getAbsolutePath() + ":");
//System.out.println(appDir.getAbsolutePath());

File app = new File(appDir, "in.amazon.mShop.android.shopping.apk");

DesiredCapabilities capabilities = new DesiredCapabilities();
capabilities.setCapability(CapabilityType.BROWSER_NAME, "");
capabilities.setCapability("deviceName", "Android");
capabilities.setCapability("platformVersion", "4.4.2");
capabilities.setCapability("platformName", "Android");
capabilities.setCapability("app", app.getAbsolutePath());
capabilities.setCapability("appPackage", "in.amazon.mShop.android.shopping");
capabilities.setCapability("appActivity", "com.amazon.mShop.home.HomeActivity");

driver = new AndroidDriver(new URL("http://127.0.0.1:4723/wd/hub"), capabilities);
driver.manage().timeouts().implicitlyWait(80, TimeUnit.SECONDS);
Thread.sleep(10000);
driver.quit();
System.out.println("DONE!");
}
}

2) Do no get in to details for now and simply run the test. To start the test just select Run > Run As > Java Application Or Right Click on Eclipse code and Click Run As  > Java Application.

3) After a few Seconds, you will see that with the help of your script, Amazon application will belaunched on your device. Once the execution is finished, you will see a long list of messages on theAppium console.We will come back to these messages later. 

Code Explanation

Lets now discuss what each line of code means in the above test. I hope you are enjoying your journey of learning Appium.

Import libraries statements

// Llibrary for Appium drivers
import io.appium.java_client.android.AndroidDriver;

// Library to create the path to APK
import java.io.File;

// Library used to verify if URL is malformed
import java.net.MalformedURLException;

// Library used to create URL for the Appium server
import java.net.URL;

// Libraries for configuring Desired Capabilities
import org.openqa.selenium.remote.CapabilityType;
import org.openqa.selenium.remote.DesiredCapabilities;

Path to APK file

Since the Amazon app apk is stored in the computer and is not already installed on the device we need to create a file object which represents the actual apk file on the disk. I placed the folder ‘/Apps/Amazon/‘ which contains the apk file inside the Eclipse project.

// Path to Eclipse project
File classpathRoot = new File(System.getProperty(“user.dir”));

// Path to <project folder>/Apps -> Amazon
File appDir = new File(classpathRoot, “/Apps/Amazon/”);

// Path to <project folder>/Apps -> Amazon/Amozon apk file
File app = new File(appDir, “in.amazon.mShop.android.shopping.apk”);

Desired Capabilities

To be able to test the app on an actual device Desired Capabilities need to be set. Desired Capabilities are a set of keys and values sent to the Appium server to tell the server what kind of automation session we’re interested in starting up. There are also capabilities used to modify the behavior of the server during automation.

// To create an object of Desired Capabilities
DesiredCapabilities capabilities = new DesiredCapabilities();

// Name of mobile web browser to automate. It should be an empty string, as we are automation an app
capabilities.setCapability(CapabilityType.BROWSER_NAME, “”);

// Name of the OS: Android, iOS or FirefoxOS
capabilities.setCapability(“platformName”, “Android”);

// Mobile OS version –  My device is running Android 4.4.2
capabilities.setCapability(CapabilityType.VERSION, “4.4.2”);

// Device name:  – I am using Micromax A311
capabilities.setCapability(“deviceName”, “Micromax A311”);

// An absolute local path to the APK file
capabilities.setCapability(“app”, app.getAbsolutePath());

// Java package of the tested Android app
capabilities.setCapability(“appPackage”, “in.amazon.mShop.android.shopping”);

// An activity name for the Android activity you want to run from your package.
capabilities.setCapability(“appActivity”, “com.amazon.mShop.home.HomeActivity”);

// Constructor to initialize driver object with new Url and Capabilities
driver = new AndroidDriver(new URL(“http://127.0.0.1:4723/wd/hub”), capabilities);

 

From: http://toolsqa.com/mobile-automation/appium/appium-tutorial/

http://toolsqa.com/mobile-automation/appium/appium-a-cross-browser-mobile-automation-tool/

Read More

XPath in Selenium: Complete Guide

In Selenium automation, if the elements are not found by the general locators like id, class, name, etc. then XPath is used to find an element on the web page .

In this tutorial, we will learn about the xpath and different XPath expression to find the complex or dynamic elements, whose attributes changes dynamically on refresh or on any operations.

Read More

XPath

1. What is XPath?

XPath is a syntax for defining parts of an XML document XPath uses path expressions to navigate in XML documents XPath contains a library of standard functions XPath is a major element in XSLT XPath is a W3C recommendation

XPath is used to navigate through elements and attributes in an XML document.

XPath is a major element in W3C's XSLT standard.

Read More

Introduction to Selendroid

Have you ever developed an Android application and publish it to Google Play? What will you do if you get a user review like -

Read More

Install appium on Ubuntu14.04

Requirements

Your environment needs to be setup for the particular mobile platforms that you want to run tests on. See below for particular platform requirements.

If you want to run Appium via an npm install, hack with or contribute to Appium, you will need node.js and npm 0.10 or greater (use n or brew install node to install Node.js. Make sure you have not installed Node or Appium with sudo, otherwise you'll run into problems). We recommend the latest stable version.

Read More

Selendroid's Architecture

Overview about the selendroid

Selendroid is based on the Android instrumentation framework, and therefore only testing one app is supported. Selendroid contains four major components:

• Selendroid-Client - the java client library (based on the selenium java client).
• Selendroid-Server - that is running beside your app on the Android device.
• AndroidDriver-App - a built in Android driver webview app to test the mobile web.
• Selendroid-Standalone - manages different Android devices by installing the selendroid-server and the app under test.

Read More

Using Hamcrest for testing - Tutorial

1. Purpose of the Hamcrest matcher framework

Hamcrest is a framework for software tests. Hamcrest allows checking for conditions in your code via existing matchers classes and allows you to define your custom matcher implementations.

To use Hamcrest matchers in JUnit you use the assertThat statement followed by one or several matchers.

Hamcrest is typically viewed as a third generation matcher framework. The first generation used assert(logical statement) but such tests were not easily readable. The second generation introduced special methods for assertions, e.g., assertEquals() but that lead to lots of assert methods. Hamcrest uses the assertThat method with a matcher expression to determine if the test was succesfully See Wiki on Hamcrest for more details.

Hamcrest has the target to make tests as readable as possible. For example the is method is a thin wrapper forequalTo(value).

Read More

Selenium in Juzu portlets

Previous steps:
– Learn how to develop great Juzu portlets for eXo Platform!
– Step 2: viewing and posting secrets
– Step 3: Building a sexy secret wall
– Step 4: adding Likes and Comments for Secret
– Step 5: Saving Secrets in the JCR
– Step 6: Let the whole world create new secrets

The JuZcret application is now finished, but our project is not perfect…

All through the previous blog posts, we have neglected to tell you about Unit Test, and this certainly is not a good practice.

The reason is that we wanted to keep you focused on a specific topic during each step. That’s why it’s only during this last step that we’ll talk about Unit Test in Juzu.

The good news is that Juzu allows you to leverage Selenium easily to simulate a real application while taking advantage of the speed of JUnit.

So it’s time to write Unit Test for our JuZcret portlet. The portlet will be deployed to an embedded portlet container. Selenium WebDriver will help to simulate almost all user interactions with the application, and then Arquillian will help to integrate with JUnit.

Read More