Have you ever seen this error in Chrome when trying to click on an element?

org.openqa.selenium.WebDriverException: 
Element is not clickable at point (411, 675)

Clicking the specific element works fine in Firefox but not at all in Chrome.

The code is very straightforward:

By locator = By.xpath("//a[attribute='value']");

WebElement element = driver.findElement(locator);

element.click();

So this does not work sometimes in Chrome.

What do you do?

Use an explicit wait

WebDriverWait wait = new WebDriverWait(driver, 25);

By locator = By.xpath("//a[attribute='value']");

WebElement element = wait.until(ExpectedConditions.
                     elementToBeClickable(locator));

element.click();

Unfortunately, this does not work either.

 Execute JavaScript

JavascriptExecutor jsExecutor;
jsExecutor = (JavascriptExecutor) driver;

String jsQuery;

jsQuery = "document.querySelector(\"[attribute='value']\").click()"; 

jsExecutor.executeScript(javaScriptCommand);

This code works sometimes only.

So, what do we do next?

Use the Actions class to chain methods

WebDriverWait wait = new WebDriverWait(driver, 25);

By locator = By.xpath("//a[attribute='value']");

WebElement element = wait.until(ExpectedConditions.
                                elementToBeClickable(locator));

new Actions(driver()).moveToElement(element)
                     .click()
                     .perform();

WebDriver driver = new FirefoxDriver();

First line you wrote in test automation.

A line used in all your test automation scripts.

So common and simple.

How does it work?

Why does it need both WebDriver and FirefoxDriver for creating the browser driver object?

Lets start.

Instead of talking about theory, we will use a concrete example.

The next test script uses only WebDriver for creating the driver object.

public class TestClass
{
String URL = http://www.vpl.ca;
By SEARCH_TEXT_BOX = By.id("globalQuery");
By SEARCH_BUTTON = By.xpath("//input[@class='search_button']");
String keyword = "java";

@Test
public void testSearch() throws Exception
{
WebDriver webDriver = new WebDriver();
webDriver.get(URL);

WebElement searchTextBox = webDriver.findElement(SEARCH_TEXT_BOX);
searchTextBox.clear();
searchTextBox.sendKeys(keyword);

webDriver.quit();
}
}

The script is very simple:

1. it creates the driver object
2. it opens the site url
3. it finds the search text box element
4. it clears the text box
5. it types a value in the text box
6. it quits the driver object

When creating the driver object, only the WebDriver type is used:

WebDriver webDriver = new WebDriver();

And we get an error in Eclipse:

cannot instantiate the type WebDriver

Logically, this makes sense.

Which browser driver are we talking about?

Is it the driver for Firefox, Chrome, Internet Explorer?

So, we can replace the WebDriver type with another type, for example, FirefoxDriver.

public class TestClass {

String URL = http://www.vpl.ca;
By SEARCH_TEXT_BOX = By.id("globalQuery");
By SEARCH_BUTTON = By.xpath("//input[@class='search_button']");
String keyword = "java";

@Test
public void testSearch() throws Exception
{
FirefoxDriver firefoxDriver = new FirefoxDriver();
firefoxDriver.get(URL);

WebElement searchTextBox = firefoxDriver.findElement(SEARCH_TEXT_BOX);
searchTextBox.clear();
searchTextBox.sendKeys(keyword);

firefoxDriver.quit();
}
}

No error is generated in this case and the code can be executed.

Since the driver object is both created and quitted in the test script, we can move these things in the test fixtures (setUp() and tearDown() methods annotated with @Before and @After):

public class TestClass {

String URL = http://www.vpl.ca;
By SEARCH_TEXT_BOX = By.id("globalQuery");
By SEARCH_BUTTON = By.xpath("//input[@class='search_button']");
String keyword = "java";
FirefoxDriver firefoxDriver;

@Before
public void setUp()
{
firefoxDriver = new FirefoxDriver();
}

@After
public void tearDown()
{
firefoxDriver.quit();
}

@Test
public void testSearch() throws Exception
{
firefoxDriver.get(URL);

WebElement searchTextBox = firefoxDriver.findElement(SEARCH_TEXT_BOX);
searchTextBox.clear();
searchTextBox.sendKeys(keyword);

}

We could even create a separate method that returns the driver object:

public class TestClass{

String URL = http://www.vpl.ca;
By SEARCH_TEXT_BOX = By.id("globalQuery");
By SEARCH_BUTTON = By.xpath("//input[@class='search_button']");
String keyword = "java";
FirefoxDriver firefoxDriver;

@Before
public void setUp()
{
firefoxDriver = getFirefoxDriver();
}

@After
public void tearDown()
{
firefoxDriver.quit();
}

@Test
public void testSearch() throws Exception
{
firefoxDriver.get(URL);

WebElement searchTextBox = firefoxDriver.findElement(SEARCH_TEXT_BOX);
searchTextBox.clear();
searchTextBox.sendKeys(keyword);

}

private FirefoxDriver getFirefoxDriver()
{
return new FirefoxDriver();
}

}

Things work pretty well in the present script.

But lets say that we want to execute the script in Chrome.

We will need to make a few changes to the test class:

• the FirefoxDriver field will use the ChromeDriver type
• a new getChromeDriver() method is needed
• the getChromeDriver) method returns a ChromeDriver object

public class TestClass {

String URL = http://www.vpl.ca;
By SEARCH_TEXT_BOX = By.id("globalQuery");
By SEARCH_BUTTON = By.xpath("//input[@class='search_button']");
String keyword = "java";
ChromeDriver chromeDriver;

@Before
public void setUp()
{
chromeDriver = getChromeDriver();
}

@After
public void tearDown()
{
chromeDriver.quit();
}

@Test
public void testSearch() throws Exception
{
chromeDriver.get(URL);

WebElement searchTextBox = chromeDriver.findElement(SEARCH_TEXT_BOX);
searchTextBox.clear();
searchTextBox.sendKeys(keyword);

}

private ChromeDriver getChromeDriver()
{
System.setProperty("webdriver.chrome.driver", "C:\\Selenium\\chromedriver.exe");
return new ChromeDriver();
}

}

This script works as well but things are getting complicated.

How can we modify the script to work for both browsers instead of having a script for each browser?

We can combine the getFirefoxBrowser() and getChromeBrowser() methods into a single method.

private ????? getDriver(String browserName) throws Exception
{
if (browserName.equalsIgnoreCase("chrome"))
return getChromeDriver();

if (browserName.equalsIgnoreCase("firefox"))
return getFirefoxDriver();

throw new Exception("invalid browser name");
}

The method has a parameter for the browserName and returns either a ChromeDriver or a FirefoxDriver object.

Obviously, this is a problem as we cannot have 2 different types as the method return type.

The method cannot return FirefoxDriver some times and ChromeDriver other times.

To solve this, we need a type that can be used instead of both FirefoxDriver and ChromeDriver.

And, you guesses, this is WebDriver.

Why can WebDriver be used instead of FirefoxDriver and ChromeDriver?

Because, in comparison with FirefoxDriver() and ChromeDriver() which are classes (so objects can be created for them), WebDriver is an interface.

An interface is just a template that is implemented by a class.

It specifies what fields and methods the class should have but without providing more details.

The classes that implement the interface will provide the methods implementations.

So WebDriver is an interface and FirefoxDriver and ChromeDriver classes that implement the WebDriver interface.

See below a part of the WebDriver interface (from selenium-java-2.52.0-srcs.jar file):

 
public interface WebDriver extends SearchContext {

void get(String url);
String getCurrentUrl();
String getTitle();
List<WebElement> findElements(By by);
WebElement findElement(By by);
String getPageSource();
void close();
void quit();

.........................................

.........................................

}

Just method declarations and no method implementations.

What about FirefoxDriver()?

FirefoxDriver() is not really implementing the WebDriver interface.

It is inheriting instead from the RemoteDriver class which implements the WebDriver interface.

This is some content of the RemoteDriver class:

public class RemoteWebDriver implements WebDriver, JavascriptExecutor,FindsById, FindsByClassName, FindsByLinkText, FindsByName, FindsByCssSelector, FindsByTagName, FindsByXPath,
HasInputDevices, HasCapabilities, TakesScreenshot {

private static final Logger logger = Logger.getLogger(RemoteWebDriver.class.getName());
private Level level = Level.FINE;

private ErrorHandler errorHandler = new ErrorHandler();
private CommandExecutor executor;
private Capabilities capabilities;
private SessionId sessionId;
private FileDetector fileDetector = new UselessFileDetector();
private ExecuteMethod executeMethod;

public void get(String url) {
execute(DriverCommand.GET, ImmutableMap.of("url", url));
}

public String getTitle() {
Response response = execute(DriverCommand.GET_TITLE);
Object value = response.getValue();
return value == null ? "" : value.toString();
}

public String getCurrentUrl() {
Response response = execute(DriverCommand.GET_CURRENT_URL);
if (response == null || response.getValue() == null) {
throw new WebDriverException("Remote browser did not respond to getCurrentUrl");
} else {
return response.getValue().toString();
}
}

public List<WebElement> findElements(By by) {
return by.findElements(this);
}

public WebElement findElement(By by) {
return by.findElement(this);
}

protected WebElement findElement(String by, String using) {
if (using == null) {
throw new IllegalArgumentException("Cannot find elements when the selector is null.");
}

Response response = execute(DriverCommand.FIND_ELEMENT,
ImmutableMap.of("using", by, "value", using));
Object value = response.getValue();
WebElement element;
try {
element = (WebElement) value;
} catch (ClassCastException ex) {
throw new WebDriverException("Returned value cannot be converted to WebElement: " + value, ex);
}
setFoundBy(this, element, by, using);
return element;
}

Lots of method implementations in this case.

That is why, in the first code example, we could not create the WebDriver object. Because WebDriver is an interface and not a class.

It is not possible to create an object for an interface and instantiate it using the interface type.

Interfaces have a very interesting characteristic, though.

It is possible to create an object for an interface and instantiate it using any of the classes that implements the interface.

For example,

WebDriver driver = new FirefoxDriver();

or

WebDriver driver = new ChromeDriver();

Looks familiar?

Having clarified the difference between WebDriver, FirefoxDriver and ChromeDriver, we can finalize the sample project code:

public class TestClass {

String URL = http://www.vpl.ca;
By SEARCH_TEXT_BOX = By.id("globalQuery");
By SEARCH_BUTTON = By.xpath("//input[@class='search_button']");
String keyword = "java";
WebDriver driver;

@Before
public void setUp() throws Exception
{
driver = getDriver("firefox"); 
//or driver = getDriver("chrome");
}

@After
public void tearDown()
{
driver.quit();
}

@Test
public void testSearch() throws Exception
{
driver.get(URL);

WebElement searchTextBox = driver.findElement(SEARCH_TEXT_BOX);
searchTextBox.clear();
searchTextBox.sendKeys(keyword);
}

private ChromeDriver getChromeDriver()
{
String chromeDriverPath = 
"C:\\Selenium\\BrowserDrivers\\chromedriver.exe";
System.setProperty("webdriver.chrome.driver", chromeDriverPath);
return new ChromeDriver();
}

private FirefoxDriver getFirefoxDriver()
{
return new FirefoxDriver();
}

private WebDriver getDriver(String browserName) throws Exception
{
if (browserName.equalsIgnoreCase("chrome"))
return getChromeDriver();

if (browserName.equalsIgnoreCase("firefox"))
return getFirefoxDriver();

throw new Exception("invalid browser name");
}

}

The driver class field uses the WebDriver interface for its type.

The getDriver() method returns a WebDriver object that is initialized with either a FirefoxDriver object or with a ChromeDriver object.

Thats why all these types are needed.

So that your scripts are flexible and can use any WebDriver object is required.

You may need sometimes to run test automation scripts in the Chrome browser using Chrome extensions.

By default, when any browser is started by Selenium, no extensions are added to it.

Also, all browser options are the default ones.

There are 2 ways of starting Chrome with extensions.

1. Use a Custom Chrome Profile

The following steps can be used for starting Chrome with a custom profile:

1. Create a folder for the new custom browser profile (example: C:\Selenium\BrowserProfile)
2. In the Chrome bar, run the following command: chrome://version/
3. Copy the Chrome executable folder path value

4. Open Command Prompt

5. Go to the Chrome executable folder path using the following 2 commands:

cd /

cd C:\Program Files (x86)\Google\Chrome\Application

5. Execute the following command:

chrome -user-data-dir=C:\\Selenium\\BrowserProfile

6. The Chrome browser is opened and a new profile is created in the C:\Selenium\BrowserProfile folder.

7. Add a new extension to Chrome by going to

Settings–> Extensions –> Get More Extensions

8. Close the browser

9. Add the needed settings to the Selenium code:

public class TestClass {

WebDriver driver;

 

@Before
public void setUp() {

System.setProperty(“webdriver.chrome.driver”, “C:\\Selenium\\BrowserDrivers\\chromedriver.exe”);

ChromeOptions options = new ChromeOptions();

options.addArguments(“user-data-dir=C:\\Selenium\\BrowserProfile”);

options.addArguments(“–start-maximized”);

driver = new ChromeDriver(options);

}

 
@After
public void tearDown() {

driver.quit();

}

 

@Test
public void testScript() {

Thread.sleep(10000);

}
}

10. Run the code; the Chrome browser is opened and the new extension is added to it

These steps are also useful if other custom settings have to be set for the browser.

2. Load a Chrome Extension

The following steps can be used for loading Chrome with an extension:

1. Run the following url in Chrome: chrome://extensions/
2. Enable the developer mode
3. Copy the id of the extension

4. Run the following url in Chrome: chrome://version/

5. Copy the Chrome profile path

6. Open the Chrome profile path in Windows Explorer

7. Open the Extensions folder

8. Open the folder that has the name equal to the extension id from step 3

9. If there is a version subfolder in the extension folder, open it

10. Copy the folder path

11. Add the needed settings to the code:

public class TestClass {

WebDriver driver;

 

@Before
public void setUp() {

String pathToExtension = “C:\\Users\\home\\AppData\\Local\\Google\\Chrome\\User Data\\Default\\Extensions\\mbopgmdnpcbohhpnfglgohlbhfongabi\\2.3.1_0”;

ChromeOptions options = new ChromeOptions();

options.addArguments(“–load-extension=” + pathToExtension);

driver = new ChromeDriver(options);

}

@After
public void tearDown() {

driver.quit();

}

@Test
public void testScript() {

Thread.sleep(10000);

}
}

12. Run the code; the Chrome browser is opened and the new extension is added to it

Taking a screenshot when your Selenium WebDriver script fails is a very useful technique.

It shows you the page where failure has happened.

The best way of taking the screenshot is through JUNIT rules.

Incorrect Way of Taking a Screenshot

A short example will be used for our “take screenshot” discussion.

The example automates a very simple test case that

1. opens the http://www.vpl.ca site
2. executes a keyword search
3. verifies that the number of results is greater than 0

The example uses the following classes:

• TEST CLASS
  • the test class extends a test base class
  • it has 1 test script only
  • the test script uses page objects and assertions

• TEST BASE CLASS
  • it is used for setting up and cleaning the test environment

• HOME PAGE CLASS
  • it implements the user actions related to the home page (open page, search)

• RESULTS PAGE CLASS
  • it implements the user actions related to results page (get results count)

• SCREENSHOT CLASS
  • it takes a screenshot of the current page

TEST CLASS

public class HomePageTests extends TestBase{

String keyword = “java”;

 

@Test
public void searchReturnsResults() throws Exception {

HomePage homePage = new HomePage();

homePage.openIn(browser);

ResultsPage resultsPage = homePage.search(keyword);

assertTrue(resultsPage.getResultCount() > 0);

}

}

TEST BASE CLASS

public class TestBase {

public static WebDriver browser;

 

@BeforeClass
public static void setUp() {
browser = new Driver().get();
}

 

@AfterClass
public static void tearDown() {
browser.quit();

}

}

HOME PAGE CLASS

public class HomePage {

By searchTextBoxId = By.id(“globalQuery”);
By searchButtonLocator = By.xpath(“//input[@class=’search_button1′]”);

String url = “http://www.vpl.ca”;

WebDriver browserDriver;

 

public void openIn(WebDriver driver) throws Exception
{
try
{
browserDriver = driver;
browserDriver.get(url);
}
catch (Exception ex)
{
new Screenshot(browserDriver).capture(“HomePage class – openIn method”);

throw new Exception(“site cannot be loaded”);
}

}

 

public ResultsPage search(String keyword) throws Exception {

try
{
WebElement searchTextBox = browserDriver.findElement(searchTextBoxId);
searchTextBox.sendKeys(keyword);

WebElement searchButton = browserDriver.findElement(searchButtonLocator);
searchButton.click();

return new ResultsPage(browserDriver);
}
catch (Exception ex)
{
new Screenshot(browserDriver).capture(“HomePage class – search method”);

throw new Exception(“search method failed”);
}

}

}

RESULTS PAGE CLASS

public class ResultsPage {

By itemCountLocator = By.xpath(“//span[@class=’items_showing_count’]”);

WebDriver browserDriver;

 

public ResultsPage(WebDriver driver)
{
browserDriver = driver;
}

 

public int getResultCount() throws Exception {

int count = 0;

try
{

WebElement resultsCount = browserDriver.findElement(itemCountLocator);

String value = resultsCount.getText();

int index1 = value.indexOf(“of”) + 3;
int index2 = value.indexOf(“items”) – 1;

count = Integer.parseInt(value.substring(index1, index2));
}
catch (Exception ex)
{
new Screenshot(browserDriver).capture(“ResultsPage class – getResultCount method”);

throw new Exception(“result count cannot be determined”);
}

return count;

}
}

SCREENSHOT CLASS

public class Screenshot {

WebDriver driver;

 

public Screenshot(WebDriver driver)
{
this.driver = driver;
}

 

public void capture(String name) {

try {

new File(“src/screenshots”).mkdirs(); 
FileOutputStream out = new FileOutputStream
(“src/screenshots/” + name + “.png”);
out.write(((TakesScreenshot) driver).getScreenshotAs(OutputType.BYTES));

out.close();

}
catch (Exception e) {
}

}

}

The Screenshot class is responsible for taking a screenshot of the current page of the site and storing it in the /src/screenshots folder.

Each of the page object classes (HomePage, ResultsPage) uses a try/catch block for catching exceptions in each of their methods.

If an exception is caught, a screenshot of the current site page is generated in the catch() block.

This approach works well but it leads to a lot of duplicated code that needs to be maintained.

Each method will need to have code for taking the screenshot in the catch() block.

The more classes you have, the more of the duplicated code.

JUNIT rules offer a great way of simplifying the process of taking a screenshot in case of failures.

Use JUNIT Rules for Automatic Screenshot Taking

JUNIT  Rules allow very flexible addition or redefinition of the behavior of each test method in a test class.

Testers can reuse or extend one of the default Rules or write their own.

The rules are useful in situations when you want to build your own test automation report, when you want to take automatic screenshots, etc.

Read more about JUNIT rules here.

A very good tutorial on JUNIT rules can be found here.

How will JUNIT rules help with our code?

First,

We create a custom JUNIT rule that takes a screenshot automatically every time an exception is generated in the project:

public class ScreenshotTestRule implements TestRule {

WebDriver driver;

 

public ScreenshotTestRule (WebDriver driver)
{
this.driver = driver;
}

 
public Statement apply(final Statement statement, final Description description) {

return new Statement() {

@Override
public void evaluate() throws Throwable {
try {
statement.evaluate();
}

catch (Throwable t) {
new Screenshot(driver).capture(getName(description.getClassName(), description.getMethodName()));

throw t;
}
}

 

private String getName(String className, String methodName) {
return className.substring(className.lastIndexOf(“.”) + 1) + “_” + methodName;
}
};
}
}

Second,

We add the JUNIT rule to the test base class:

public class TestBase {

public static WebDriver browser;

 

@Rule
public ScreenshotTestRule screenshotTestRule = new ScreenshotTestRule(browser);

 

@BeforeClass
public static void setUp() {
browser = new Driver().get();
}

 

@AfterClass
public static void tearDown() {
browser.quit();

}

}

Third,

We remove the “screenshot” code from the page object classes:

public class HomePage {

By searchTextBoxId = By.id(“globalQuery”);
By searchButtonLocator = By.xpath(“//input[@class=’search_button1′]”);

String url = “http://www.vpl.ca”;

WebDriver browserDriver;

 

public void openIn(WebDriver driver) throws Exception
{
try
{
browserDriver = driver;
browserDriver.get(url);
}
catch (Exception ex)
{
throw new Exception(“site cannot be loaded”);
}

}

 

public ResultsPage search(String keyword) throws Exception {

try
{
WebElement searchTextBox = browserDriver.findElement(searchTextBoxId);
searchTextBox.sendKeys(keyword);

WebElement searchButton = browserDriver.findElement(searchButtonLocator);
searchButton.click();

return new ResultsPage(browserDriver);
}
catch (Exception ex)
{
throw new Exception(“search method failed”);
}

}

}

How does this work?

Every time an exception happens, the JUNIT custom rule is triggered.

The JUNIT rule generates a screenshot of the current page (the one where the exception occurs).

The screenshot is then saved in the /src/screenshot folder.

I hope that this article makes it clear how to take screenshots in your automation projects.

If you liked it, please share it with your friends.

Test automation starts with a test case.

For example:

1. open the home page of the site (http://www.vpl.ca)

2. run a keyword search

3. validate that the number of results for the keyword search is greater than 0

The test case is high level and includes actions that a user would take.

To automate it, it needs to be described at a lower level:

1. open the home page of the site (http://www.vpl.ca)

2. run a keyword search

2.1 find the search textbox element
2.2 type a keyword in the search textbox element
2.3 find the search button
2.4 click the search button

3. validate that the number of results for the keyword search is greater than 0

3.1 find the result count label element
3.2 get the value of the result count label
3.3 extract the number of results from the result count value
3.4 verify that the number of results is greater than 0

The code of the test automation script is below:

@Test
public void testFirstResult() {

String url = “http://www.vpl.ca”;

By searchTextBoxLocator = By.xpath(“//input[@id=’globalQuery’]”);

By searchButtonLocator = By.xpath(“//input[@class=’search_button’]”);

By resultsCountLocator = By.xpath(“//span[@class=’items_showing_count’]”);

 

driver.get(url);

WebElement searchField = driver.findElement(searchTextBoxLocator );

searchField.click();

searchField.sendKeys(“java”);

WebElement searchButton = driver.findElement(searchButtonLocator );

searchButton.click();

WebElement resultCountLabel = driver.findElement(resultsCountLocator );

String resultCountValue = resultCountLabel.getText();

int index1 = resultCountValue.indexOf(“of”) + 3;
int index2 = resultCountValue.indexOf(“items”) – 1;

resultCountValue = resultCountValue.substring(index1, index2);

int resultCount = Integer.parseInt(resultCountValue);

assertTrue(resultCount > 0);

}

The script includes many WebDriver API objects and methods:

• WebElement objects
• By objects
• driver.findElement() method
• getText() method
• click(), sendkeys() methods()

Manual testers learning test automation write code that looks like this.

The code works.

Imagine having 50 other scripts similar to this.

What’s wrong here?

Scripts like this one have multiple problems:

– they are difficult to understand by manual testers with no programming experience
– they are difficult to change
– they are difficult to maintain

This way of writing test automation code is incorrect as per Simon Stewart, creator of Selenium WebDriver:

If you have WebDriver APIs in your test methods, You’re Doing It Wrong.

Simon Stewart.

So how do we fix the test scripts?

The Page Object Model helps:

“A page object wraps an HTML page, or fragment, with an application-specific API, allowing you to manipulate page elements without digging around in the HTML.”

Martin Fowler

This model states that page object classes should be created for each web page of the site.

The page object classes implement the interaction with the site using Selenium WebDriver APIs.

The test automation scripts use then the page object classes and assertions.

Basically, what we should do is to structure the test script so that it follows not the detailed test case but the high level one:

@Test
public void testResultsInfo()
{

HomePage home = new HomePage(driver);

home.open();

ResultsPage results = home.search();

assertTrue(results.resultsCount() > 0);

}

The test script does not include WebDriver API any longer.

It is as easy to read as the high level test case.

It uses 2 page object classes:

1. HomePage
2. ResultsPage

Lets see how the code can be added to these 2 classes.

HomePage class

It implements all user actions for the home page.

In this case, there are 2 actions only:

1. open() – open the home page of the site
2. search() – run a keyword search

public class HomePage
{

WebDriver driver;

String url = “http://www.vpl.ca”;

By searchTextBoxLocator = By.xpath(“//input[@id=’globalQuery’]”);

By searchButtonLocator = By.xpath(“//input[@class=’search_button’]”);

public HomePage(WebDriver driver)
{

this.driver = driver;

}
public void open()
{

driver.get(url);

}

public ResultsPage search(String keyword)
{

WebElement searchField = driver.findElement(searchTextBoxLocator);

searchField.click();

searchField.sendKeys(keyword);

WebElement searchButton = driver.findElement(searchButtonLocator);

searchButton.click();

return new ResultsPage(this.driver);

}

ResultsPage class

For the results page, we just need to have a method that returns the number of results:

public class ResultsPage {

WebDriver driver;

By resultsCountLocator = By.xpath(“//span[@class=’items_showing_count’]”);

public ResultsPage(WebDriver driver)
{

this.driver = driver;

}

public integer resultsCount()
{

WebElement resultCountLabel = driver.findElement(resultsCountLocator);

String resultCountValue = resultCountLabel.getText();

int index1 = resultCountValue.indexOf(“of”) + 3;
int index2 = resultCountValue.indexOf(“items”) – 1;

resultCountValue = resultCountValue.substring(index1, index2);

int resultCount = Integer.parseInt(resultCountValue);

return returnCount;

}

To summarize, the test automation scripts should not include WebDriver APIs.

Page object classes should be created for implementing user actions for each page.

The test scripts should use only page objects and assertions.