Selenium WebDriver - Building a Continuous Integration System with Java Tools

Introduction

As we promise, this week we will explain how to integrate java, webdriver, intellij idea, junit, maven, hudson. The objective is to have a continuous integrated system, to run the automated tests during night.

The following will be covered:

• Installing Java, Intellij IDEA, Maven, Firefox 
• Configuring Intellij IDEA and Maven for Selenium WebDriver. Also, we will show you how to create your first project in Intellij IDEA
• Installing Hudson for continuous integration 
• Using Hudson and Maven for test execution

Installing Java, Intellij IDEA, Maven, Firefox

Below you can see a diagram with the required tools in order to use WebDriver with Java

As we already mentioned, we will use Maven, Intellij.

Installing Firefox and the necessary plugins

• Go to getfirefox.com and download Firefox
• Install the following plugins: firebug (debugger used to identify objects), Selenium IDE (used to record actions; beginner users can use this), firepath (used to identify the absolute/relative path  and Element locator for WebDriver (very usefull to identify by xpath an element and can be used with element right-click-->Java locators)

Installing Java

• Check first if java is not already installed on your computer (open a command prompt and type java - version)
• If not, than go to the oracle site and install the correct version of java: http://www.oracle.com/technetwork/java/javase/downloads/index.html
• Go to Environment variables (Computer --> Properties --> Advanced System Settings --> Environment variables) and check if the java variable  (location to bin installation folder; e.g. C:\Program Files\Java\jdk1.8.0_25\bin\) is added to the system path
• Now, when you type  java - version you will see that java was installed

Installing Maven

• Download latest Maven corresponding to you system from http://maven.apache.org/download.cgi
• Place the unzip file under folder C:\Program Files\Apache Software Foundation 
• Create the user variable M2_HOME (Computer --> Properties --> Advanced System Settings --> Environment variables --> New User variable - not a system variable). Pay attention, if the maven version changes, then you should update this variable)

• Create M2 user variable that points to the Maven bin folder

• Add the user variable path (not a system) variable that contains the path to Maven bin folder %M2_HOME\bin%

• Create JAVA_HOME user variable that points to java root directory

• Reopen the command prompt and check that maven was installed mvn--version

Installing Intellij

• Download latest version from https://www.jetbrains.com/idea/download/. Select the community edition which is free

Configuring Intellij IDEA and MAven for Selenium WebDriver

In order to work with Maven, we need to create a new Maven Intellij project and to set the path to the jdk location. Then give a group and artifact id and then the project name and location.

When the project is generated, it is important to enable auto import. By doing this (message appears on the top right corner), all maven dependencies will automatically be imported.

In order to write selenium tests we need to bring first junit and then selenium in our maven pom.xml file. The following information should be added:

Now we can add our first test. Create a Test class from Java-->New Class and name the class. It is important that the class name contains in it's name the word test so that maven can run tests from this class.

Installing Hudson for Continuous Integration System

Now that we found out how we can write the tests, we should be able to use a continuous integration system that can automatically run our tests. There are different tools that can be used like TFS build, Hudson, Teamcity.

Hudson is a CI server for the Java development community. Running tests with Hudson and and Maven needs both tools installed on the server.

• The tool can be downloaded from here: http://hudson-ci.org/. 
• The .war file should be deployed on the server where you want to run your tests. 
• Create a .bat file on your desktop that contains this java -jar "...path to the file\hudson-3.1.2.war"

Using Hudson and Maven for Test Execution 

• Access you Hudson page by using this link http://localhost:8080/. You can access Hudson from other workstation. To do this just replace 'localhost' with the server host name.
• Add a new hjob and select Maven 2/3 option

• Go to the job configuration page and in Advanced Job page set the maven workspace that you are going to use

• Go to Build area and add 2 steps: one that has as goal the cleaning of the project before the build and the other the running of the tests. For both steps we need to set the path to the pom.xml file.

• If your project is under a source control system you need to adjust the settings from Source Code Management group
• If you want to build your project at a specific hour go to Build Triggers group and make the changes in Build periodically field
• Save the configuration

This is the end oh the story. Next time we will see how to integrate Selenium WebDriver in Visual Studio.

Happy testing and... make it green, becomes a dream :).

Selenium WebDriver with Java - Create Helper Classes (2)

Introduction

Last week we stated to present an automation testing framework by using: java, webdriver, intellij idea, junit, maven, log4j, hudson. This week we will continue creating a class that will contain functions in order to work with controls.

ControlUtils

In this chapter we will write functions for working with controls and also how to use them.

FluentWait

Before starting we need a way to wait an element on the page until it will be displayed. We may either use an implicit wait, by waiting a number of seconds or either waiting the element until is displayed on the page.

- implicit wait

public static void wait_time(long fWait){
    try {
        Thread.sleep(fWait);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

Use it like this:

wait_time(1000); --> this will wait 1 second

- explicit wait

public static WebElement fluentWait(final By locator){
    long timeStart = System.currentTimeMillis();

    Wait<WebDriver> wait = new FluentWait<WebDriver>(selenium)
            .withTimeout(30, TimeUnit.SECONDS)
            .pollingEvery(5, TimeUnit.SECONDS)
            .ignoring(NoSuchElementException.class);

    WebElement foo = wait.until(
            new Function<WebDriver, WebElement>() {
                public WebElement apply(WebDriver driver) {
                    return driver.findElement(locator);
                }
            }
    );

    long timeEnd = System.currentTimeMillis();
    logger.info("Element waited for: " + (timeEnd - timeStart) + " ms.");

    return  foo;
};

Functions for Controls

- get_text

public static String get_text(By byValue) {
    WebElement element = fluentWait(byValue);
    String elementText = null;
    elementText = element.getText();

    return elementText;
}

This function will get the control's text and can be used like this:

String submitButton = ControlUtils.get_text(By.id("loginBtn"));

- verify text

public static boolean verify_text(By byValue, String fText) {

    String fTextOut = fluentWait(byValue).getText();
    if (fTextOut.equals(fText)) {
        return true;
    } else {
        return false;
    }
}

This function will return true or false and will check if the control's text is correct. You can use it like this.

boolean submitButton = ControlUtils.verify_text(By.id("loginBtn"), "Sign in");
Assert.assertEquals("Submit button text is not correct", true, submitButton);

- element_present

public static boolean element_present(By byValue) {
    if (fluentWait(byValue).isDisplayed()) {
        return true;
    } else {
        return false;
    }
}

This function will return true or false and will check if the control is present or not on the page. You can use it like this.

Assert.assertEquals("Delete button is not present", true, ControlUtils.element_present(By.id("btnLeaveDelete")));

- click_element

public static void click_element(By byValue)
{
    WebElement element = fluentWait(byValue);
    element.click();
}

This function will click an element on the page. Use it like this:

ControlUtils.click_element(By.id("loginBtn"));

- double_click_element

public static void double_click_element(By byValue){
    WebElement elementToDoubleClick = fluentWait(byValue);

    Actions action=new Actions(selenium);
    action.doubleClick(elementToDoubleClick);
    action.perform();
}

This is used to double-click an element. Usage:

ControlUtils.double_click_element(By.id("loginBtn"));

- get_attribute

public static String get_attribute(By byValue, String fAttribute) {
    return fluentWait(byValue).getAttribute(fAttribute);
}

The function will get a specific attribute from a control. Usage:

String startDateText = ControlUtils.get_attribute(By.id("inputleaveStartDate"), "value");

- is_attribute_present

public static boolean is_attribute_Present(WebElement element, String attribute)
{
    Boolean result = false;
    try {
        String value = element.getAttribute(attribute);
        if (value != null){
            result = true;
        }
    } catch (Exception e) {}

    return result;
}

This will check if an attribute of a control is present or not. Imagine for example that you have to test if a control is or not disabled. Usage:

WebElement disapproveButton = fluentWait(By.id("btnLeaveDisapprove"));
Assert.assertEquals("Disapprove button is not disabled", true, ControlUtils.isAttributePresent(disapproveButton, "disabled"));

- send_keys

public static void send_keys(By byValue, String fText)
{
    WebElement element = fluentWait(byValue);
    element.sendKeys(fText);
}

This function will write some text in a control. Usage:

ControlUtils.send_keys(By.id("inputleaveStartDate"), "01-01-2014");

- refresh_page

public static void refresh_page() {
    Actions actionObject = new Actions(selenium);
    actionObject.keyDown(Keys.CONTROL).sendKeys(Keys.F5).perform();
}

If you need to refresh the page use this function.

- functions for selection controls

// Clear all selected entries. This is only valid when the SELECT supports * multiple selectionspublic static void select_deselect_all(By byValue, String fxPath){
    Select selectBox = new Select(fluentWait(byValue));
    selectBox.deselectAll();
}

//Select none the option at the given index. This is done by examining the * "index" attribute of an element, and not merely by countingpublic static void select_deselect_by_index(By byValue, int index) {
    Select selectBox = new Select(fluentWait(byValue));
    selectBox.deselectByIndex(index); }

//Select none all options that have a value matching the argument. */public static void select_deselect_by_value(By byValue, String value) {
    Select selectBox = new Select(fluentWait(byValue));
    selectBox.deselectByValue(value);
}

//Select none all options that display text matching the argumentpublic static void select_deselect_by_visible_text(By byValue, String matchingArgument) {
    Select selectBox = new Select(fluentWait(byValue));
    selectBox.deselectByVisibleText(matchingArgument);
}

//Gets all selected options belonging to this select tag.public static String select_get_all_selected_options(By byValue) {
    Select selectBox = new Select(fluentWait(byValue));
    List<WebElement> selectOptions = selectBox.getAllSelectedOptions();
    String selectText = "";
    String cumulatedSelectText = "";
    for (WebElement temp : selectOptions) {
        selectText=temp.getText();
        cumulatedSelectText= cumulatedSelectText + " " + selectText;
        System.out.println("cumulatedSelectText: " + cumulatedSelectText);
    }

    return cumulatedSelectText;
}

//Gets the first selected option in this select tag (or the currently * selected option in a normal selectpublic static String select_get_first_selected_option(By byValue) {
    Select selectBox = null;
    selectBox = new Select(fluentWait(byValue));
    System.out.println(selectBox.getFirstSelectedOption().getText());

    return selectBox.getFirstSelectedOption().getText();
}
//Gets all options belonging to this select tagpublic static void select_get_options(By byValue) {
    Select selectBox = new Select(fluentWait(byValue));
    List<WebElement> selectOptions = selectBox.getOptions();
    for (WebElement temp : selectOptions) {
        System.out.println("getText" + temp.getText());
    }
}

//Whether this select element support selecting multiple options at the * same time? This is done by checking the value of the "multiple" * attribute.public static void select_is_multiple(By byValue) {
    Select selectBox = new Select(fluentWait(byValue));
    System.out.println(selectBox.isMultiple());
}

//Select all options that have a value matching the argument.public static void select_select_by_value(By byValue, String value) {
    Select selectBox = new Select(fluentWait(byValue));
    selectBox.selectByValue(value);
}

//Select the option at the given indexpublic static void select_select_by_index(By byValue, int index) {
    Select selectBox = new Select(fluentWait(byValue));
    selectBox.selectByIndex(index);
}

//Select all options that display text matching the argumentpublic static void select_select_by_visible_text(By byValue, String matchingArgument) {
    Select selectBox = new Select(fluentWait(byValue));
    selectBox.selectByVisibleText(matchingArgument);
}

Next week we will present how to install and set java, webdriver, intellij idea, junit, maven, log4j, hudson. I hope you liked this article. Happy testing and... make it green, becomes a dream :).

Selenium WebDriver with Java - Create Helper Classes (1)

Introduction

In this article we will start presenting a Selenium WebDriver framework. The following are used:
- Java
- Intellij IDEA 14 Community edition IDE
- Junit for tests
- maven
- log4j library for logging
- Hudson for continuous integration
In a future article we will present how to install and integrate all these components.

DriverUtils

First of all we can create a DriverUtils class that will contain functions for starting the web driver, getting the browser, opening the desired url, closing browser, login, logout, functions to be executed before and after all tests are run or after all test from a class are run. Also, we can include here a function that will log, at the beginning of each test, a name and a description.
Let's start!

Start WebDriver

public static void open_driver(String bName)
{
    logger.info("Opening selenium driver");
    selenium = null;
    String path = System.getProperty("user.dir");

    if(bName.equals(ConstantsHelpers.firefoxBrowser))
    {
        FirefoxProfile firefoxProfile = new FirefoxProfile();
        selenium = new FirefoxDriver(firefoxProfile);
        selenium.manage().window().maximize();
    }
    else if(bName.equals(ConstantsHelpers.ieBrowser))
    {
        DesiredCapabilities caps = DesiredCapabilities.internetExplorer();
        caps.setCapability(InternetExplorerDriver.INTRODUCE_FLAKINESS_BY_IGNORING_SECURITY_DOMAINS, true);
        System.setProperty("webdriver.ie.driver", path + "\\IEDriver\\IEDriverServer.exe");
        selenium = new InternetExplorerDriver(caps);
        selenium.manage().window().maximize();
    }
    else if(bName.equals(ConstantsHelpers.chromeBrowser))
    {
        ChromeOptions options = new ChromeOptions();
        options.addArguments("--disable-web-security");
        DesiredCapabilities caps = DesiredCapabilities.chrome();
        caps.setCapability(ChromeOptions.CAPABILITY, options);
        System.setProperty("webdriver.chrome.driver", path + "\\ChromeDriver\\chromedriver.exe");
        selenium = new ChromeDriver(caps);
        selenium.manage().window().maximize();
    }

    else if(bName.equals(ConstantsHelpers.safariBrowser))
    {
        selenium = new SafariDriver();
        selenium.manage().window().maximize();
    }
}

Some tips about this function:

• selenium is declared globally

public static WebDriver selenium;

• selenium is set and get

//Function to get selenium driver
public static WebDriver getSelenium() { return selenium; }
//Function to set selenium driver
public static void setSelenium(WebDriver selenium) { DriverUtils.selenium = selenium;}

• for working with Chrome and IE drivers we need to download the exe drivers and include them in the project. To set the path we use

String path = System.getProperty("user.dir");

• The name of the drivers are stored in a ConstantsHelpers class 

public static String ieBrowser = "IE";
public static String firefoxBrowser = "Mozilla";
public static String safariBrowser = "Safari";
public static String chromeBrowser = "Chrome";

• Capabilities: describes a series of key/value pairs that encapsulate aspects of a browser. You can find more information about this on the internet

Get browser

//Browser type: change constant if you want to run test on different browser//Available browsers are: IE, Chrome, Firefox, Safaripublic static String getBrowser() {
    return ConstantsHelpers.firefoxBrowser;
    //return ConstantsHelpers.chromeBrowser;    //return ConstantsHelpers.ieBrowser;    //return ConstantsHelpers.safariBrowser;

}

Open url

In order to open your url you can create a function

//Function that opens the desired url for your applicationpublic static void open_url()
{
    logger.info("Opening url " + ConstantsHelpers.url);
    selenium.get(ConstantsHelpers.url);
}

where the url is define in a ConstantsHelpers class

public static String url="http://my_url.com";

Close browser

//Closes browser/driverpublic static void close_browser()
{
    logger.info("Closing browser and driver");
    getSelenium().close();
    getSelenium().quit();
}

Wait time 
This is a function used to implicitly wait the specified amount of time in milliseconds

public static void wait_time(long fWait){
    try {
        Thread.sleep(fWait);
    } catch (InterruptedException e) {
        e.printStackTrace();
    }
}

You can use it like this:

wait_time(5000);

@Before, @BeforeClass, @AfterClass, @After
Depending on your project, you can set some actions to be taken:
- before starting tests @Before
- before starting tests from a class @BeforeClass
- after running all tests from a class @AfterClass
- after running all tests @After

Here are some examples:

@BeforeClassstatic public final void setUpBeforeClass() throws Exception {
    String browser = DriverUtils.getBrowser();
    open_driver(browser);
}

@Beforepublic void setUp() throws Exception
{
    open_url();
}

@AfterClassstatic public void tearDownAfterClass() throws Exception
{
    close_browser();
}

Login, Logout
Supposing you web page has a login page, you can include the Login, Logout function in @BeforeClass and @AfterClass annotations.
Below you have a login example:

public static void login(String username, String password) {
    logger.info("Logging in with '" + username + "' userName and language " + password);

    ControlUtils.send_keys(By.id("language-select"), ConstantsHelpers.language);
    ControlUtils.send_keys(By.id("username"), username);
    ControlUtils.send_keys(By.id("password"), password);

    ControlUtils.fluentWait(By.id("loginBtn")).click();
}

Test Case Description
Another function that we added in this class is the one that, in the test logs, at the beginning of each test, writes a brief description about the test to be run.

public static void TestCaseDescription(String title, String description)
{
    String browser=DriverUtils.getBrowser();

    logger.info("---------------------------------------------------------------------");
    logger.info("This test was executed in '" + browser + "' browser.");
    logger.info("---------------------------------------------------------------------");
    logger.info("Test executed in class '" + StackTraceInfo.getInvokingClassName() + "' and in method '" + StackTraceInfo.getInvokingMethodName() + "'.");
    logger.info("---------------------------------------------------------------------");
    logger.info("Test title '" + title + "'.");
    logger.info("---------------------------------------------------------------------");
    logger.info("Test description '" + description + "'.");
    logger.info("---------------------------------------------------------------------");
}

The function uses log4j library and a class for getting the class and method name. But we will talk about these in future stories
The function can be used like this: TestCaseDescription("Test name", "Test description");
and the result in the test run will look like this:

Hope you enjoyed this article.

Automate a Web/Desktop application by using AutoIt

Introduction

A few days ago we talked about the possibility to use a Sikuli library in Selenium in order to perform integration tests between a web and a desktop application. Sikuli uses visual identification to automate and test graphical user interfaces (GUI). It automates anything you see as a user on the screen without being necessary to identify objects.

This tool can be used also in selenium when we interact with native UI. For example, the web application provides a file upload/download feature that invokes native OS UI for selecting a file, or when we are required to enter credentials in a password popup, or when it is very difficult to identify elements from a chart, for example.

Another way to do this is to use AutoIt which it is a freeware BASIC-like scripting language designed for automating the Windows GUI and general scripting. It uses a combination of simulated keystrokes, mouse movement and window/control manipulation in order to automate tasks.

More about AutoIt

You can download the tool from https://www.autoitscript.com/site/autoit/downloads/. You need to download AutoIt latest version and the editor SciTE. After installation you can create shortcuts for AutoIt Window Info, SciTE and Au3Record.

AutoIt Window Info is used to identify objects on the screen. Think about Firebug. It's something similar.

Au3Record is used to record actions you perform. Think about Selenium IDE. The recorder can be found in the installation path under ..AutoIt3\Extras\Au3Record\Au3Record.exe.

SciTE is an editor you can use to write your tests. Bellow you can see the code for the test previously recorded.

After you write the test go to Tools-->Compile and an .exe file will be generated in the specified folder. 
We will not continue telling more about how to write tests in AutoIt, because this is a separate discussion. The question is how to integrate the script in Selenium?

Integrate Selenium WebDriver and AutoIt scripts

Well, this is very simple :

where

If I'd have to choose between Sikuli and AutoIt to perform integration tests between Web and Desktop, I'll use Sikuli. But for cathing UI elements like upload/download., I'll use AutoIt.

Automate a Web/Desktop application by using Sikuli library

Introduction

Have you ever worked for a combined Web-Desktop project and your boss said “Make automation tests to test the Web application but also to test integration between the Desktop and the Web application and take into consideration to use open-source tools because out budget is limited?”. Well, there is a solution for everything!

First, let’s better understand what a Web-Desktop architecture means: some companies can offer a diverse amount of software packages that must work together. It is important not only to test individual packages but also the chain between them. The problem may be that individual applications can have different bases. In the image below we can observe that any change done in the Desktop application should be integrated in the Web application.

Because we are dealing with both testing a Web application and also with the integration Web-Desktop, a solution would be to use:

•           Selenium WebDriver for testing the Web application;
•           Selenium WebDriver and Sikuli for the integration.

Integrate Selenium WebDriver and Sikuli in the Same IDE

It doesn't make sense to say too much about Selenium WebDriver because this a free tool already well known and commonly used.

Sikuli[1] is an open-source research project that automates anything we see on the screen. It uses image recognition to identify and control GUI components. It is useful when there is no easy access to a GUI's internal or source code, this means that the only requirement here is that the objects that are tested to be on the screen.

You’ve probably already guessed that in our testing framework we are going to use Sikuli to simulate actions in the Desktop application and then with Selenium, we will check the integration of the data in the Web application. In order to achieve this we do not want to use an IDE for Selenium and another one for Sikuli. How can we obtain this result?

•      Install Java;
•      Use Intellij IDEA + Maven for Selenium;
•      The core of SikuliX is written in Java, which means we can use the SikuliX API as a standard     JAVA library in our program. Download sikulixapi.jar from Sikuli site;
•      In the Maven pom.xml file add the following dependency;         

•  Import classes we need in our applications: import org.sikuli.script.*;
•   Because we will have to capture images on the screen to identify object, installing the Sikuli    software is anyway required. The reason we want to use it is because Target Offset        functionality will help us to indicate where exactly we want to execute an action in the Sikuli  object. Let’s imagine a text with a label near it. If we want to click on the textbox and not on  the label, the functionality will help us to click on the specified coordinates;

•           The objects (image) should be saved on the disk and used in Intellij IDEA.

Basic Framework for Web-Desktop Integration

Having integrated sikulixapi.jar dependency in Maven, we are now able to access Sikuli methods by declaring objects of type Screen, Pattern and App:

The most important features about a screen object are: click, double click, type. We can create functions to simulate these actions like described below. It is better to keep all these helpers in a separate class:

Click:

DoubleClick:

Type:

What is the meaning of SikuliWaitElement method? To perform operations on an image, we need to make sure that the image is visible on the screen. Therefore we can expect a number of seconds until the picture appears on the screen. This is not the safest solution because we cannot be sure that indeed the image will be available after the number of seconds indicated (maybe the desktop application is slow). An alternative would be to wait in a loop one second until reading a desired result (while image does not exist, wait one second). But this is also not a complete solution because it may happen that the object does not even exist, which means that the execution of the test would not stop. The best way is to wait a maximum number of seconds. If during this period we find the object, then we can go to the next step, otherwise we will stop the test. Here is an example:

IsImageAvailable function should verify if the image is present or not on the screen.

For every image we should declare a constant. We should also have a constant that gives us the path to the images folder. It is wise to keep these constants in a separate class.

Then, we can use our image like below (the example clicks on the desired image):

If we want to minimize the run time of our scripts it is recommended to simulate keyboard functionalities by using TypeImage function previously exemplified instead of using a lot of images. Below we can see an example of how we can use this function. Suppose in the Remote Assistance Settings dialog we want to change the settings in order to have

•        Allow this computer to be controlled remotely à unchecked
•         Set the maximum amount of time invitations can remain open à 6 Minutes
•        Create invitations that can only be used from computers running Windows Vista or later à checked

Initially the dialog looks like this:

We can write this code in order to obtain the desired result after Allow this computer to be controlled remotely image was captured:

Other Important Functionalities. Screen Class [2]

Until now we discussed about the most used functions: Click, DoubleClick, Type, Wait and Exists. But besides these, there are other interesting functions in sikulixapi.jar library, like:

FindAll(image) searches the entire screen for all the matching visual patterns and returns a list of locations of those similar patterns. We can use this function for example for unchecking all check-boxes on a page.

DragDrop(image1, image2) takes two images as arguments. The first image describes the source GUI object to drag and the second image describes the appearance of the destination location where the GUI object should be dragged to and dropped.

Drag(image) starts a drag-and-drop operation by dragging at the given click point.

Hover(image) makes the mouse cursor hover over an object.

RightClick(image) performs a mouse click on the click point using the right button.

MouseDown(button) presses and holds left mouse. We can simulate a combination of the button constants Button.LEFT, Button.MIDDLE, Button.RIGHT.

MouseMove(image) moves the mouse to a new location indicated by the image.

MouseUp(button) releases mouse button.

Wheel(image, WHEEL_DOWN | WHEEL_UP, steps) moves the mouse pointer to a location indicated by the image and turn the mouse wheel in the specified direction by the specified number of steps.

Paste(image, text) pastes the text at a click point.

Highlight(second) highlights the region for some period of time.

Other Important Functionalities. App Class [3]

Opening an application à App.open(application name).

Switching to a different application à App.focus(application name)

Closing an application à App.close(application name).

Other Important Functionalities. Pattern Class [4]

GetFilename gets the filename of the image contained in the Pattern object.

Conclusion

We succeeded, in this article, to find a solution to automatically test the integration between two totally different systems in a single IDE.

Even Sikuli is not an automation test tool that depends on the code, it is a very usable and user-friendly tool. Testers that haven’t worked with automation tools before will notice in a short time that they will be able, by adding only a few lines of code, to perform very easily the main actions like clicking, double-clicking and typing on an object.

Sikuli completely depends on what’s shown on the screen, can be sensitive to resolution differences and also the tests are content-sensitive and can be affected by the object layout changes. However, Sikuli included in Java is an alternative for integrating two different systems and, also, can be used to compare objects in the web page that are difficult to catch with Selenium.

References

[1] http://www.sikuli.org/

[2] http://sikulix-2014.readthedocs.org/en/latest/screen.html

[3] http://sikulix-2014.readthedocs.org/en/latest/globals.html

[4] http://sikulix-2014.readthedocs.org/en/latest/pattern.html