Scribd
Upload
7 views5 pages

Fluent Interface Method Chaining.: Homepage Loginpage Registrationpage

The Fluent Page Object Model simplifies the implementation of the Page Object Model design pattern in automation testing by utilizing method chaining for improved code readability and maintainability. This approach allows for a more streamlined test code, as demonstrated through a registration example on a website, where methods return the current page object to facilitate chaining. The document emphasizes the importance of selecting appropriate design patterns and maintaining the automation framework for effective testing.

Uploaded by

Sandhya Tanushkodi
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
7 views5 pages

Fluent Interface Method Chaining.: Homepage Loginpage Registrationpage

The Fluent Page Object Model simplifies the implementation of the Page Object Model design pattern in automation testing by utilizing method chaining for improved code readability and maintainability. This approach allows for a more streamlined test code, as demonstrated through a registration example on a website, where methods return the current page object to facilitate chaining. The document emphasizes the importance of selecting appropriate design patterns and maintaining the automation framework for effective testing.

Uploaded by

Sandhya Tanushkodi
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as DOCX, PDF, TXT or read online on Scribd
You are on page 1/ 5

Fluent Page Object Model

Implementing OOPs concept in any automation framework involves dealing with lots of page classes
and objects. Most of the time, the test code required to implement these objects and methods
becomes very complex. This complexity can be minimised by using Fluent Interface and Method
Chaining.

Page Object Model is the most popular and widely used design pattern as it helps in code readability
and maintainability. And it can be more simplified and readable by using Fluent Page Object Model
as it uses method chaining.

In this design pattern, every action method in the page class returns this to implement chaining
methods for the business logic. This does not mean you cannot return other page class objects. You
can either return this (same class) or another page class too.

Method chaining is a technique where one method is called directly on another method forming a
chain-like structure.

Let us understand Fluent Page Object Design Pattern with the help of registration example
in http://automationpractice.com/index.php website

Step 1 Create HomePage, LoginPage, and RegistrationPage page classes with locators and action
methods.

Code snippet for RegistrationPage. Likewise you can create other pages.

public class RegistrationPage {

WebDriver driver;

@FindBy(css = "div#uniform-id_gender2")

private WebElement mrsRadio;

@FindBy(css = "input#customer_firstname")

private WebElement firstName;

@FindBy(css = "input#customer_lastname")

private WebElement lastName;

@FindBy(css = "input#passwd")

private WebElement password;

@FindBy(css = "input#firstname")
private WebElement addFirstName;

@FindBy(css = "input#lastname")

private WebElement addLastName;

@FindBy(css = "input#city")

private WebElement city;

@FindBy(css = "input#postcode")

private WebElement postcode;

@FindBy(css = "button#submitAccount")

private WebElement registerBtn;

RegistrationPage(WebDriver driver) {

this.driver=driver;

PageFactory.initElements(driver, this);

public RegistrationPage selectFemaleTitle() {

System.out.println("driver; " +driver);

mrsRadio.click();

return this;

public RegistrationPage enterFirstName(String first) {

firstName.sendKeys(first);

return this;

}
public RegistrationPage enterLastName(String last) {

lastName.sendKeys(last);

return this;

public RegistrationPage enterPassword(String pass) {

password.sendKeys(pass);

return this;

public RegistrationPage enterAddFirstName(String first) {

addFirstName.sendKeys(first);

return this;

public RegistrationPage enterAddLastName(String last) {

addLastName.sendKeys(last);

return this;

public RegistrationPage enterCity(String cityName) {

city.sendKeys(cityName);

return this;

public RegistrationPage enterCode(String post) {

postcode.sendKeys(post);

return this;

public HomePage clickRegister() {


registerBtn.click();

return new HomePage(driver);

public static RegistrationPage using(WebDriver driver) {

return new RegistrationPage(driver);

In the RegistrationPage page class, methods such


as enterFirstName, enterLastName and enterPassword return this and clickRegister returns
a HomePage object. This shows that it is not mandatory for the methods to always return this.

Step 2 Create FluentDesignTest test class

public class FluentDesignTest {

public void register() {

RegistrationPage.using(driver)

.selectFemaleTitle()

.enterFirstName("Peter")

.enterLastName("John")

.enterPassword("Test@123")

.enterAddFirstName("Peter")

.enterAddLastName("John")

.enterCity("Los Angeles")

.enterCode("88205")

.clickRegister();

In the above test class, we are not creating objects of page classes to access the associated methods.
Instead, a single chain is created to call all the required methods of a page class in one call itself.

The fluent page objects significantly improve the readability of tests. Also, it is quite easy to write
tests with Fluent style.

Conclusion
As an automation tester, you might come across several problems in framework on a daily basis and
sometimes you might do a quick fix at test level to keep the test execution up and running. However,
this solution may not last for long. It is recommended that QAs should identify problems and try to
fix it at base level by creating common wrapper methods that can be used by multiple test classes.

You should also figure out if this problem can be solved by implementing proper design patterns and
try to implement it in the early stages of automation framework development. Constantly evaluating
the problems and updating the automation code/structure is the key for a successful automation
framework.

Hence, choosing and implementing the right Design Pattern which suits your test automation
requirements is the key to efficient testing.

Using BrowserStack Automate for web testing and App Automate for mobile app testing, you can
seamlessly integrate your Selenium, Cypress, Playwright, Puppeteer, Cucumber, and Appium tests to
make automation testing easier through your desired Design Pattern. Not just that, you can speed up
your tests by 30x with parallel testing to expand your test and browser coverage without
compromising on build times.

You might also like