Instant Selenium Testing Tools Starter

Selenium is a browser automation framework. It provides a number of tools and APIs for automating user interaction on pure HTML and JavaScript applications in browsers such as IE, Firefox, Google Chrome, Safari, and many more. However, Selenium does not support Rich Internet Application (RIA) technologies such as Silverlight, Flex/Flash, and JavaFx out of the box.

Selenium offers the following set of tools for automating interaction with browsers:

Selenium is widely used for automated testing of web applications; however, its usage is not limited to testing. Selenium mimics user actions such as entering text into a text field, clicking on buttons or links, selecting an option from a drop-down list, and many more, in a browser window as if a human user is interacting with the application. Selenium is also used for screen scraping and automating repetitive tasks in web applications.

You can use Selenium for functional/acceptance testing of your web applications. You can create automated regression tests using Selenium and run them whenever you need to test a new build of your application.

You can use Selenium to automate repetitive tasks such as data entry, filling out forms, check status, or perform complex navigation steps while manual testing.

Before you install Selenium IDE, you will need to check that you have all of the required elements, as listed:

The easiest way to download Selenium IDE as a Firefox add-on is from http://seleniumhq.org.

Installing Selenium IDE is quick and easy, similar to installing any other add-on in Firefox. Selenium IDE Version 1.10.1 is supported on Firefox Version 19:

By this point, you should have a working installation of Selenium IDE, and you should be free to play around and discover more about it. Installing Selenium IDE is as simple as installing any other add-on or extension for Firefox. In the next section, you will see the power Selenium IDE has and how useful it is for automating and testing web applications.

In this section we will show you how to record a test on a demo e-commerce application. We will test the product search feature of the application using the following steps:

Before we play back the recorded test, let's save it in Selenium IDE:

In Selenium IDE, we can group multiple tests in a test suite. Let's create a test suite and Selenium IDE will automatically add SearchTest to this suite:

Selenium IDE provides multiple ways to execute the tests:

Selenium IDE is great to start, however, you will need more to build a test automation framework. Complex tests, with conditional statements and logic, parameterization cannot be automated very well using Selenium IDE. In addition to this you might need features such as detailed logging and reporting, error handling particularly unexpected errors, database testing, and integration with other testing tools and frameworks that are not supported by Selenium IDE.

For building a flexible, maintainable, and robust framework, you will need to use Selenium WebDriver.

Selenium WebDriver is a simple API that helps you with browser automation. However, when using it for testing and building a test framework, there is much more needed. You will need to integrate Selenium WebDriver API with different libraries, tools, and so on, for test development. You will need an integrated development environment (IDE) to build your test project and inject other dependencies in to the framework.

We will show how to use Eclipse for developing tests with Selenium WebDriver. Eclipse is a very popular IDE in the Java world. Eclipse provides a feature-rich environment for Selenium WebDriver test development in Java. Along with Eclipse, Apache Maven also provides support for managing the entire lifecycle of a test project. Maven is used to define project structure, dependencies, build, and test management.

You can use Eclipse and Maven for building your Selenium WebDriver test framework from a single window. Another important benefit of using Maven is that you can get all the Selenium library files and their dependencies by configuring the pom.xml file. Maven automatically finds and downloads the dependencies to the project from the Maven central repository while building the project. In this section we will show you how to configure a new Maven project in Eclipse with the following steps:

Apart from Java, Selenium WebDriver bindings are available for a number of other programming languages:

One of the key features of Selenium is support for running tests on a variety of web browsers available. You can develop a test on one browser and run it on all the supported browsers as needed. This feature is essential for cross-browser testing of your web application. You can run tests on combinations of operating systems and web browsers.

One of the key features of Selenium is its ability to locate different types of elements used on a page and the ability to interact with them. Selenium provides various ways or strategies to locate elements and perform actions such as clicking, typing text, selecting an option from the element, or performing verification on the state or property of the element, such as a text value. We can also check if the element is enabled or disabled, is checked or unchecked.

The following table describes some of the important locator strategies that you can use with IDE or WebDriver API:

In addition to the aforementioned strategies, Selenium WebDriver supports the following strategies:

Selenium provides an extensive support for the standard HTML elements used on a web page. You can interact with the HTML elements by using built-in commands and APIs for building simple to complex tests. The following table shows some key commands and API methods for interacting with a page and its elements:

Selenium WebDriver provides the WebElement class for interacting with HTML elements.

When Selenium scripts are played back, the application may not always respond with the same speed, especially for applications using AJAX. For example, it might take a few seconds for the following:

You can handle these anticipated timing problems by synchronizing your script to ensure that Selenium waits until your application is ready before performing a certain step. There are several options that you can use to synchronize your script using Selenium IDE and Selenium WebDriver.

The Page Object pattern provides tests for an interface, where a test can operate on the logical functionality offered by the page in a manner similar to the user accessing the page, but by hiding its internals. For example, if we build a Page Object for a login page that will provide a method to log in by accepting the username and password, and will take the user to the home page of the application. The test need not worry about what type of input controls are used for the login page, their locator details, navigation, and so on.

Tests should use objects of a page at a high level, where any change in layout or attributes used for the fields in the underlying page should not break the test.

Selenium WebDriver provides outstanding support for implementing the Page Object pattern via its PageFactory class. The Page Object pattern brings the following advantages for your tests:

The login page class provides an interface to the login page of the application to the tests as shown in the following diagram:

Here is Page Object for the login page of the test application.

The login page class contains locator details for the key elements needed for user login functionality. Elements from the login page are defined as private members of the LoginPage class. The test code will not have access to these elements. The LoginPage class provides a public login() method to the tests. The test needs to pass the e-mail address and password for a registered user to this method. The constructor of the LoginPage class uses the PageFactory.initElements() method to initialize WebElements defined in the class in the following way:

package demo.magentocommerce.pages;


import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.support.FindBy;
import org.openqa.selenium.support.PageFactory;

public class Login {

  @FindBy(id="email")
  private WebElement emailField;

  @FindBy(id="pass")
  private WebElement passwordField;

  @FindBy(id="send2")
  private WebElement loginButton;

  public Login(WebDriver driver) {
    PageFactory.initElements(driver, this);
  }

  public void login(String email, String password) {
    emailField.sendKeys(email);
    passwordField.sendKeys(email);
    loginButton.click();
  }
}

Here is a sample test using the LoginPage class. The instance of the LoginPage class is created by passing the current driver instance. The login() method is called in the following way:

...
//Navigate to the Login Page
WebDriver driver = new FirefoxDriver();
driver.get("http://demo.magentocommerce.com/customer/account/login/");

//Create an instance of Login page and call the Login function 
LoginPage loginPage = new LoginPage(driver);
loginPage.login("xxx@xx.com","xxxx");

//Verify the user is logged in
...