Test Automation - How To extend selenium functionality using Lombok extension methods

Introduction

As a Java developer, you may have heard of the popular library called Lombok. In this article, we will explore an extension method, a feature of Lombok that is relatively little known. Additionally, we will discuss how extension methods can provide Selenium WebDriver with missing functionality.

What is Lombok?

Lombok is a Java library that helps reduce boilerplate code in Java programs by providing a set of annotations that can generate common code constructs, such as getters, setters, and constructors, at compile time.

For example, consider the following Java user class:

public class User {
    private String name;
    private int age;

    public User(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

With Lombok, you can annotate the class with @Data and Lombok will generate the required getters, setters, and constructors for you at compile time:

import lombok.Data;

@Data
public class User {
    private String name;
    private int age;
}

This can save a lot of time and reduce the amount of code you have to write. Lombok also provides other useful annotations, such as @Getter, @Setter, and @Builder, which allow you to generate specific code constructs based on your needs.

What are Extension Methods?

In addition to providing code generation annotations, Lombok also introduces a new feature called extension methods. Extension methods are a way to add new methods to an existing class without modifying the class itself.

C# has extension methods similar to this concept. This method allows you to add new methods to a class by creating a static class containing the desired methods. A Lombok extension method works similarly, but it’s defined as a static method within the class.

To define an extension method in Lombok, you annotate a static method with @ExtensionMethod. The first parameter of the method must be the type of the class being extended, and the method can then be called on instances of that class as if it were an instance method.

For example, consider the following extension method that adds a reverse() method to the String class:

package extensions;

import lombok.experimental.UtilityClass;

@UtilityClass
public class StringExtension {

    public String reverse(String self) {
        return new StringBuilder(self).reverse().toString();
    }
}

This extension method can now be called on any String object as if it were an instance method:

package extensions;

import lombok.experimental.ExtensionMethod;

@ExtensionMethod(StringExtension.class)
public class StringExample {
    public static void main(String[] args) {
        String str = "Hello World!";
        System.out.println(str.reverse());
    }
}

Extension Methods with Selenium

Now that we have a basic understanding of extension methods and how they work, let’s see how we can use them in combination with Selenium WebDriver.

Selenium is a popular open-source library for automating web browsers. It provides a set of APIs that allow you to control a web browser and interact with web pages programmatically.

Writing long and repetitive code to perform common tasks can be one of the challenges of using Selenium. This includes finding and interacting with elements on a web page. Using extension methods can simplify and improve the readability of this code.

For example, consider the following code that uses Selenium to find an element on a web page and click it:

package extensions;

import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;
import org.openqa.selenium.chrome.ChromeDriver;

public class SeleniumExample {

    public static void main(String[] args) {
        WebDriver driver = new ChromeDriver();
        driver.get("https://www.example.com");
        WebElement element = driver.findElement(By.id("submit-button"));
        element.click();
    }
}

This extension method simplifies the process of finding and clicking an element on a web page. Instead of having to find the element and then call the click() method on it separately, you can call the findAndClick() method directly on the WebDriver object.

package extensions;

import lombok.experimental.UtilityClass;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.WebElement;

@UtilityClass
public class WebDriverExtension {

    public static void findAndClick(WebDriver self, By by) {
        WebElement element = self.findElement(by);
        element.click();
    }
}

Here is how you would use the findAndClick() extension method in your code:

package extensions;

import lombok.experimental.ExtensionMethod;
import org.openqa.selenium.By;
import org.openqa.selenium.WebDriver;
import org.openqa.selenium.chrome.ChromeDriver;

@ExtensionMethod(WebDriverExtension.class)
public class SeleniumExample {

    public static void main(String[] args) {
        WebDriver driver = new ChromeDriver();
        driver.get("https://www.example.com");
        driver.findAndClick(By.id("submit-button"));
    }
}

This code is shorter and easier to read than the original version, and it provides the same functionality.

In conclusion

In this article, we discussed the Lombok library and its extension methods feature. Extension methods are a useful way to add new methods to an existing class without modifying the class itself, and they can be used to simplify and improve the readability of your code.

It is possible to add missing functionality to Selenium WebDriver using Lombok extension methods. As a result, interacting with web pages will be easier.

Overall, Lombok and its extension methods can be a valuable addition to your Java toolkit, and they can help you write cleaner, more readable code.

Happy testing!