Selenium Testing Tools Cookbook: Over 90 recipes to help you build and run automated tests for your web applications with Selenium WebDriver

You will need Eclipse and Maven to set up the test development environment. Download and set up Maven from http://maven.apache.org/download.html. Follow the instructions on the Maven download page (see the Installation Instructions section on the page).

Download and set up Eclipse IDE for Java Developers from https://eclipse.org/downloads/.

Let's configure Eclipse with Maven to develop Selenium WebDriver tests using the following steps:

Eclipse provides the ability to create Selenium WebDriver test projects easily with its Maven plugin, taking away the pain of project configurations, directory structure, dependency management, and so on. It also provides a powerful code editor to write the test code.

When you set up a project using Maven in Eclipse, it creates the pom.xml file, which defines the configuration of the project and its structure. This file also contains the dependencies needed for building, testing, and running the code. For example, the following code shows the dependency information about Selenium WebDriver that we added in pom.xml:

<dependency>
    <groupId>org.seleniumhq.selenium</groupId>
    <artifactId>selenium-java</artifactId>
    <version>2.47.1</version>
</dependency>

Most open source projects publish this information on their websites. In this case, you can check http://seleniumhq.org/download/maven.html; you can also get this information from Maven Central at http://search.maven.org/#browse. Maven will automatically download libraries and support files mentioned for all the dependencies and add to the project without you needing to find, download, and install these files to the project. This saves a lot of our time and effort while managing the dependency-related tasks.

Maven also generates a standard directory structure for your code, for easier management and maintenance. In the previous example, it created the src/test/java folder for the test code and the src/test/resources folder to maintain resources needed for testing, such as test data files, utilities, and so on.

Maven provides life cycle steps such as building the test code and running the test. If you are working with the Java development team, then you might find the application code and test code together in Maven. Here, Maven supports building the application code, then firing the tests, and releasing the software to production.

Maven can also be used to execute the test from the command line. To run tests from the command line, navigate to the SeleniumCookbook project folder through the command line and type the following command:

mvn clean test

This command will traverse through all the subdirectories and run the clean command to delete/remove earlier build files. It will then build the project and run the tests. You will see the results at the end of execution on command line, as shown in the following screenshot:

You can also download and configure Ant from http://ant.apache.org/bindownload.cgi for other OS platforms.

Windows users can download and install WinAnt on Windows. WinAnt comes with an installer that will configure Ant through the installer. The WinAnt installer is available at http://code.google.com/p/winant/.

This recipe uses WinAnt on the Windows OS.

You will also need Selenium WebDriver and JUnit JAR files. You can download Selenium JAR file from http://selenium-release.storage.googleapis.com/ and JUnit JAR file from https://github.com/junit-team/junit/wiki/Download-and-Install.

Let's set up the SeleniumCookbook created in the previous recipe project for Ant with the following steps:

Ant needs a build.xml file with all the configurations and steps required to build the project. We can add steps for report generation, sending e-mail notification, and so on to build.xml. Ant provides a very dynamic framework for defining steps in the build process.

Ant also needs the necessary library/JAR files to be copied in the lib folder, which are needed for building the project.

Ant scans for the complete set of tests in the project and executes these tests in a way similar to Maven.

NuGet comes bundled with Microsoft Visual Studio 2012 onwards. However, for Microsoft Visual Studio 2010, you will need to download and install NuGet from http://nuget.codeplex.com.

Let's configure Microsoft Visual Studio 2013 to develop Selenium WebDriver tests using the following steps:

NuGet Package Manager adds the external dependencies to Microsoft Visual Studio projects. It lists all available packages and automatically downloads and configures packages to the project. It also installs dependencies for the selected packages automatically. This saves a lot of effort in configuring the projects initially.

You will need Python or Ruby installed before installing the Selenium WebDriver client library.

Installation and setting up Selenium WebDriver with Python or Ruby is simple using following steps.

Installing Selenium WebDriver with Python

You can install Selenium WebDriver with Python using the pip tool with the following command line:

pip install selenium

This will get the latest version of Selenium WebDriver Python client library installed. That's it.

Let's create a simple test in Python using this installation. Create a google_search.py file in your favorite editor or IDE and copy the following code:

import unittest
from selenium.webdriver.support import expected_conditions
from selenium import webdriver
from selenium.webdriver.support.ui import WebDriverWait


class GoogleSearch(unittest.TestCase):
    def setUp(self):
        self.driver = webdriver.Firefox()
        self.driver.implicitly_wait(30)
        self.base_url = "https://www.google.com/"

    def test_google_search(self):
        driver = self.driver
        driver.get(self.base_url)

        element = driver.find_element_by_idname("q")
        element.clear()
        element.send_keys("Selenium testing tools cookbook")
        element.submit()

        WebDriverWait(driver, 30)\
            .until(expected_conditions.title_contains("Selenium testing tools cookbook"))
        self.assertEqual(driver.title, "Selenium testing tools cookbook - Google Search")

    def tearDown(self):
        self.driver.quit()

if __name__ == "__main__":
    unittest.main(verbosity=2, warnings="ignore")

You can run this test using the following command line:

python google_search.py

The Python interpreter will execute the test and you will see a Firefox window being opened and performing the search operation on Google.com. At the end of the execution you will see the results, as shown in the following screenshot:

Installing Selenium WebDriver with Ruby

You can install Selenium WebDriver with Ruby using the gem tool with following command line:

gem install selenium-webdriver

This will get the latest version of Selenium WebDriver Ruby client library installed. That's it.

Let's create a simple test in Ruby using this installation. Create a google_search.rb file in your favorite editor or IDE and copy the following code:

require "selenium-webdriver"
gem "test-unit"
require "test/unit"

class GoogleSearch < Test::Unit::TestCase
  def setup
    @driver = Selenium::WebDriver.for :firefox
    @base_url = "https://www.google.com/"
    @driver.manage.timeouts.implicit_wait = 30
  end

  def test_google_search
    @driver.get(@base_url)

    element = @driver.find_element(:name, "q")
    element.clear
    element.send_keys "Selenium testing tools cookbook"
    element.submit()

    wait = Selenium::WebDriver::Wait.new(:timeout => 10)
    wait.until { @driver.title.include? "Selenium testing tools cookbook" }

    assert_equal "Selenium testing tools cookbook - Google Search", @driver.title
  end

  def teardown
    @driver.quit
  end
end

You can run this test using the following command line:

ruby google_search.rb

Ruby interpreter will execute the test and you will see a Firefox window being opened and performing the search operation on Google.com. At the end of the execution you will see the results, as shown in the following screenshot:

Selenium WebDriver is supported on various programming languages. For each supported language, a client library or language binding is published by the Selenium developers. These client libraries have Selenium WebDriver classes and functions that are needed to create automation scripts.

These libraries can be installed using package installers available with the respective languages. In this case, we used pip for Python, which connected to the PyPI (Python Package Index) source using the Internet, downloaded the latest Selenium WebDriver Python client library and installed with the Python directory. Similarly, Selenium WebDriver Ruby Gem is installed using the gem utility.

You need to download Internet Explorer Driver Server from http://docs.seleniumhq.org/download/. It is available in both 32bit and 64bit versions.

After downloading the IEDriver server, unzip and copy the file to the same directory in which the scripts are stored.

Let's create a test that uses Internet Explorer Driver Server with the following steps:

Internet Explorer Driver Server is a stand-alone server executable that implements WebDriver's JSON-wire protocol, which works as a glue between the test script and Internet Explorer, as shown in following diagram:

The tests should specify the path of the IEDriverServer executable before creating the instance of Internet Explorer. This is done by setting the webdriver.ie.driver property as shown in following code:

System.setProperty("webdriver.ie.driver",
    "src/test/resources/drivers/IEDriverServer.exe");

Internet Explorer Driver Server supports automating major IE versions on Windows XP, Vista, Windows 7, and Windows 8 operating systems.

We need to create an instance of the InternetExplorerDriver class, which will connect to the Internet Explorer Driver Server to launch the Internet Explorer, shown as follows. It will then run the Selenium commands, which we will call by using various WebDriver and WebElement methods from the test script:

DesiredCapabilities caps = new DesiredCapabilities().internetExplorer();

caps.setCapability(
InternetExplorerDriver.INTRODUCE_FLAKINESS_BY_IGNORING_SECURITY_DOMAINS,
true);

// Launch Internet Explorer
driver = new InternetExplorerDriver(caps);

We used the DesiredCapabilities class to set the INTRODUCE_FLAKINESS_BY_IGNORING_SECURITY_DOMAINS capability, which defines to ignore the browser protected mode settings during the start by IEDriverServer.

Selenium provides the ability to run tests on remote machines by using the RemoteWebDriver class. We can configure any browser that Selenium supports for executing tests on a remote machine. To run tests on a remote machine, we need to run the Selenium Server and the Internet Explorer Driver Server on a remote machine and use RemoteWebDriverClass, as shown in the following code sample:

DesiredCapabilities caps = new DesiredCapabilities().internetExplorer();

caps.setCapability(
InternetExplorerDriver.INTRODUCE_FLAKINESS_BY_IGNORING_SECURITY_DOMAINS,
true);

// Connect with Remote Selenium Server with specified URL and capabilities
driver = new RemoteWebDriver(new URL("http://192.168.1.3:4444/hub/wd"), caps);

We can connect any browser to a remote server using the preceding method.

You need to download ChromeDriver from https://sites.google.com/a/chromium.org/chromedriver/downloads.

ChromeDriver is a standalone server executable that implements WebDriver's JSON-wire protocol and works as a glue between the test script and Google Chrome, as shown in the following diagram:

The tests should specify the path of the ChromeDriver executable before creating the instance of Chrome. This is done by setting the webdriver.chrome.driver property as shown in the following code:

System.setProperty("webdriver.chrome.driver","src/test/resources/drivers/chromedriver.exe");
    "src/test/resources/drivers/chromedriver.exe");

We can also specify a path externally through the –Dwebdriver.chrome.driver option using Maven command line options. In this case, we don't need to set up this property in test; we need to create an instance of ChromeDriver class that will connect to the ChromeDriver Server, as shown in the following code. It will then run the Selenium commands that we will call by using various WebDriver and WebElement methods from the test script:

driver = new ChromeDriver();

You need to download and install Microsoft WebDriver Server on Windows 10 from https://www.microsoft.com/en-us/download/details.aspx?id=48212.

Add a new test and name it as GoogleSearchTestOnEdge.java and add the following code:

package com.secookbook.examples.chapter01;

import static org.junit.Assert.*;

import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.edge.EdgeDriver;
import org.openqa.selenium.edge.EdgeOptions;
import org.openqa.selenium.support.ui.ExpectedCondition;
import org.openqa.selenium.support.ui.WebDriverWait;

public class GoogleSearchTestOnEdge {

  private WebDriver driver;

  @Before
  public void setUp() {
    System.setProperty("webdriver.edge.driver",
        "C:\\Program Files (x86)\\Microsoft Web Driver\\MicrosoftWebDriver.exe");

    EdgeOptions options = new EdgeOptions();
    options.setPageLoadStrategy("eager");

    // Launch a new Edge instance
    driver = new EdgeDriver(options);

    // Navigate to Google
    driver.get("http://www.google.com");
  }

  @Test
  public void testGoogleSearch() {
    // Find the text input element by its name
    WebElement element = driver.findElement(By.name("q"));

    // Clear the existing text value
    element.clear();

    // Enter something to search for
    element.sendKeys("Selenium testing tools cookbook");

    WebElement button = driver.findElement(By.name("btnG"));
    button.click();

    // Google's search is rendered dynamically with JavaScript.
    // Wait for the page to load, timeout after 10 seconds
    new WebDriverWait(driver, 10).until(new ExpectedCondition<Boolean>() {
      public Boolean apply(WebDriver d) {
        return d.getTitle().toLowerCase()
            .startsWith("selenium testing tools cookbook");
      }
    });

    assertEquals("Selenium testing tools cookbook - Google Search",
        driver.getTitle());
  }
  @After
  public void tearDown() throws Exception {
    // Close the browser
    driver.quit();
  }
}

Execute this test and you will see a Microsoft Edge window being launched and all the steps executed.

Microsoft WebDriver Server is a standalone server executable that implements WebDriver's JSON-wire protocol, that works as a glue between the test script and the Microsoft Edge browser, as shown in the following diagram:

The tests should specify the path of Microsoft WebDriver Server executable before creating the instance of Microsoft Edge. This is done by setting the webdriver.edge.driver property as shown in the following code:

System.setProperty("webdriver.edge.driver",
        "C:\\Program Files (x86)\\Microsoft Web Driver\\MicrosoftWebDriver.exe");