Selenium Testing Tools Cookbook: Unlock the full potential of Selenium WebDriver to test your web applications in a wide range of situations. The countless recipes and code examples provided ease the learning curve and provide insights into virtually every eventuality.

Selenium WebDriver implements a very comprehensive API for working with web elements, Advanced User Interactions, executing JavaScript code, and support for various types of controls such as List, Dropdown, Radio Button, and Checkbox.

In this chapter, we will explore how these APIs can be used to build simple to complex test steps. This chapter will also help in overcoming some common issues while building tests with Selenium WebDriver. The chapter examples are created with Selenium WebDriver Java bindings. The sample code for this chapter contains some of these recipes implemented with C#, Ruby, and Python.

While testing a web application, we need to verify that elements are displaying correct values or text on the page. Selenium WebDriver's WebElement API provides various ways to retrieve and verify text. Sometimes, we need to retrieve text or value from an element into a variable at runtime and later use it at some other place in the test flow.

In this recipe, we will retrieve and verify text from an element by using the WebElement class' getText() method .

@Test
public void testElementText()
{
  //Get the message Element
  WebElement message = driver.findElement(By.id("message"));
  
  //Get the message elements text
  String messageText = message.getText();
  
  //Verify message element's text displays "Click on me and my //color will change"
  assertEquals("Click on me and my color...

Developers configure various attributes of elements displayed on the web page during design or at runtime to control the behavior or style of elements when they are displayed in the browser. For example, the <input> element can be set to read-only by setting the readonly attribute.

There will be tests that need to verify that element attributes are set correctly. We can retrieve and verify an element's attribute by using the getAttribute() method of the WebElement class.

In this recipe, will check the attribute value of an element by using the getAttribute() method.

@Test
public void testElementAttribute()
{
  WebElement message = driver.findElement(By.id("message"));
  assertEquals("justify",message.getAttribute("align"));
}

Various styles are applied on elements displayed in a web application, so they look neat and become more usable. Developers add these styles using CSS (also known as Cascading Style Sheets). There may be tests that need to verify that correct styles have been applied to the elements. This can be done using WebElement class's getCSSValue() method, which returns the value of a specified style attribute.

In this recipe, we will use the getCSSValue() function to check the style attribute defined for an element.

@Test
public void testElementStyle()
{
  WebElement message = driver.findElement(By.id("message"));
  String width = message.getCssValue("width");
  assertEquals("150px",width);
}

The Selenium WebDriver's Advanced User Interactions API allows us to perform operations from keyboard events and simple mouse events to complex events such as dragging-and-dropping, holding a key and then performing mouse operations by using the Actions class, and building a complex chain of events exactly like a user doing these manually.

The Actions class implements the builder pattern to create a composite action containing a group of other actions.

In this recipe, we will use the Actions class to build a chain of events to select rows in a table.

@Test
public void testRowSelectionUsingControlKey() {
  
  List<WebElement...

There will be elements in a web application that need double-click events fired for performing some actions. For example, double-clicking on a row of a table will launch a new window. The Advanced User Interaction API provides a method to perform double-click.

In this recipe, we will use the Actions class to perform double-click operations.

@Test
public void testDoubleClick() throws Exception
{
  WebDriver driver = new ChromeDriver();
  driver.get("http://dl.dropbox.com/u/55228056/DoubleClickDemo.html");
    
  WebElement message = driver.findElement(By.id("message"));
    
  //Verify color is Blue
  assertEquals("rgb(0, 0, 255)",message.getCssValue("background-color").toString());
  
  Actions builder = new Actions(driver);
  builder.doubleClick(message).build().perform();
  
  //Verify Color...

Selenium WebDriver implements Selenium RC's dragAndDrop command using Actions class. As seen in earlier recipes the Actions class supports advanced user interactions such as firing various mouse and keyboard events. We can build simple or complex chains of events using this class.

In this recipe, we will use the Actions class to perform drag-and-drop operations.

@Test
public void testDragDrop() {
  
  driver.get("http://dl.dropbox.com/u/55228056/DragDropDemo.html");
  
  WebElement source = driver.findElement(By.id("draggable"));
  WebElement target = driver.findElement(By.id("droppable"));

  Actions builder = new Actions(driver);
  builder.dragAndDrop(source, target).perform();
  try
  {
    assertEquals("Dropped!", target.getText());
  } catch (Error e) {
    verificationErrors.append(e.toString());
  }
}

Selenium WebDriver API provides the ability to execute JavaScript code with the browser window. This is a very useful feature where tests need to interact with the page using JavaScript. Using this API, client-side JavaScript code can also be tested using Selenium WebDriver. Selenium WebDriver provides a JavascriptExecutor interface that can be used to execute arbitrary JavaScript code within the context of the browser.

In this recipe, we will explore how to use JavascriptExecutor for executing JavaScript code. This book has various other recipes where JavascriptExecutor has been used to perform some advanced operations that are not yet supported by the Selenium WebDriver.

@Test
public void testJavaScriptCalls() throws Exception
{
  WebDriver...

Selenium WebDriver provides the TakesScreenshot interface for capturing a screenshot of a web page. This helps in test runs, showing exactly happened when an exception or error occurred during execution, and so on. We can also capture screenshots during verification of element state, values displayed, or state after an action is completed.

Capturing screenshots also helps in verification of layouts, field alignments, and so on where we compare screenshots taken during test execution with baseline images.

In this recipe, we will use the TakesScreenshot interface to capture a screenshot of the web page under test.

@Test
public void testTakesScreenshot()
{
  try {
    File scrFile = ((TakesScreenshot)driver).getScreenshotAs(OutputType.FILE);
    FileUtils.copyFile(scrFile, new File("c:\\tmp\\main_page.png"));
  } catch (Exception e...

While running tests with RemoteWebDriver or Grid it is not possible to take the screenshots, as the TakesScreenshot interface is not implemented in RemoteWebDriver.

However, we can use the Augmenter class which adds the TakesScreenshot interface to the remote driver instance.

In this recipe, we will use the Augmenter class to capture a screenshot from RemoteWebDriver.

driver = new Augmenter().augment(driver);
File scrFile = ((TakesScreenshot)driver).getScreenshotAs(OutputType.FILE);
FileUtils.copyFile(scrFile, new File("c:\\tmp\\screenshot.png"));

driver = new Augmenter().augment(driver);

Selenium RC's windowMaximize() command was missing in Selenium WebDriver. However starting from release 2.21, Selenium WebDriver supports maximizing the browser window.

In this short recipe, we will see how to maximize the browser window.

driver = new FirefoxDriver();
driver.manage().window().maximize();

driver.manage().window().maximize();

Selenium WebDriver supports testing Dropdown and List controls using a special Select class instead of the WebElement class.

The Select class provides various methods and properties to interact with dropdowns and lists created with the HTML <select> element.

In this recipe, we will automate Dropdown and List control using Select class.

@Test
public void testDropdown()
{
  //Get the Dropdown as a Select using its name attribute
  Select make = new Select(driver.findElement(By.name("make")));
  
  //Verify Dropdown does not support multiple selection
  assertFalse(make.isMultiple());
  //Verify Dropdown has four options for selection
  assertEquals(4, make.getOptions().size());
  
  //With Select class we can select an option in Dropdown using //Visible Text
  make.selectByVisibleText("Honda");
  assertEquals...

While testing the dropdowns and lists created with the <select> element, there will be a need to check that correct options are displayed for user selection. These options may be static or populated from a database.

In this recipe we will see how options can be checked against the expected values.

@Test
public void testDropdown()
{
  //Get the Dropdown as a Select using its name attribute
  Select make = new Select(driver.findElement(By.name("make")));
  
  //Verify Dropdown does not support multiple selection
  assertFalse(make.isMultiple());
  //Verify Dropdown has four options for selection
  assertEquals(4, make.getOptions().size());
  
  //We will verify...

In earlier recipes, we saw how to select options in the Dropdown and List controls as well as check what options are available for selection. We also need to verify that the correct options are selected in these controls, either by default or by the user.

In this recipe, we will see how to check options which are selected in a dropdown or list.

@Test
public void testDropdown()
{
  ...
  
  //With Select class we can select an option in Dropdown using //Visible Text
  make.selectByVisibleText("Honda");
  assertEquals("Honda", make.getFirstSelectedOption().getText());
  
  //or we can select an option in Dropdown using value attribute
  make.selectByValue...

Selenium WebDriver supports Radio Button and Radio Group controls using the WebElement class. We can select and deselect the radio buttons using the click() method of the WebElement class and check whether a radio button is selected or deselected using the isSelected() method.

In this recipe, we will see how to work with the Radio Button and Radio Group controls.

@Test
public void testRadioButton()
{
  //Get the Radiobutton as WebElement using it's value attribute
  WebElement petrol = driver.findElement(By.xpath("//input[@value='Petrol']"));
  
  //Check if its already selected? otherwise select the Radiobutton 
  //by calling click() method 
  if (!petrol.isSelected())
    petrol.click();
  
  //Verify Radiobutton is selected 
  assertTrue(petrol.isSelected());
  
  //We can also get all the Radiobuttons from a Radio...

Selenium WebDriver supports Checkbox control using the WebElement class. We can select or deselect a checkbox using the click() method of the WebElement class and check whether a checkbox is selected or deselected using the isSelected() method.

In this recipe, we will see how to work with the Checkbox control.

@Test
public void testCheckBox()
{
  //Get the Checkbox as WebElement using it's value attribute
  WebElement airbags = driver.findElement(By.xpath("//input[@value='Airbags']"));
  
  //Check if its already selected? otherwise select the Checkbox
  //by calling click() method
  if (!airbags.isSelected())
    airbags.click();
  
  //Verify Checkbox is Selected
  assertTrue(airbags.isSelected());

  //Check Checkbox if selected? If yes, deselect it
  //by calling click() method
  if (airbags.isSelected())
    airbags.click();
  
  //Verify Checkbox is Deselected...

Selenium WebDriver Java bindings provide the WindowsUtils class with methods to interact with the Windows operating system. During test runs, there might be a need to close open instances of browser windows or processes at the beginning of the test. By using the WindowsUtils class, we can control the process and perform tasks, such as killing an open process, and so on.

In this recipe, we will use the WindowsUtils class to kill the open browser window.

@Before
public void setUp()
{
  WindowsUtils.tryToKillByName("firefox.exe");
  driver = new FirefoxDriver();
  driver.get("http://www.google.com");
  driver.manage().window().maximize();
}

WindowsUtils.tryToKillByName...

The WindowsUtils class provides various methods to interact with the registry on the Windows operating system. While running tests on the Windows operating system and Internet Explorer, the test might need to read and modify IE settings or there may be a need to get some settings related to the web server or database from the registry in tests. The WindowsUtils class comes handy in these situations.

In this recipe, we will use WindowsUtil to read the exact name of the operating system on which the test is running. We might need this information printed in our test logs.

String osname = WindowsUtils.readStringRegistryValue("HKEY_LOCAL_MACHINE\\SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\ProductName");
System.out.println(osname);

The WindowsUtils class also provides methods to update existing Windows registry values or create new registry keys and values. Similar to reading registry values, WindowsUtils class provides multiple methods to modify keys and values.

In this recipe, we will use the WindowsUtils class to create a new registry key with a string value.

WindowsUtils.writeStringRegistryValue("HKEY_CURRENT_USER\\SOFTWARE\\Selenium\\SeleniumVersion", "2.24");
assertEquals("2.24",WindowsUtils.readStringRegistryValue("HKEY_CURRENT_USER\\SOFTWARE\\Selenium\\SeleniumVersion")); 

WindowsUtils...