Understanding and Refactoring Selenium Tests Using LoadableComponent

Understanding and Refactoring Selenium Tests Using LoadableComponent

3 July 2024 Stephan Petzl Leave a comment QA

Refactoring Selenium tests can be a daunting task, especially when encountering complex patterns like LoadableComponent. This guide aims to clarify the purpose and implementation of LoadableComponent, as well as provide practical examples to help you refactor your tests effectively.

What is LoadableComponent?

LoadableComponent is a design pattern used in Selenium to ensure that a page is fully loaded before interacting with it. This pattern utilizes a method called isLoaded() to verify the page’s status and throws an error if the page is not loaded. While this approach might seem unconventional, it ensures that your tests only proceed when the page is ready.

Refactoring LoadableComponent

One common criticism of the LoadableComponent pattern is its reliance on error handling to control execution flow. According to the design principle “use exceptions only for exceptional use,” this approach might appear counterintuitive. However, understanding the underlying logic can help in effectively refactoring your tests.

Using Assertions for Page Load Verification

Instead of relying solely on error handling, you can use JUnit assertions to check if the page is loaded. JUnit assertions throw errors to signal that something went wrong, which can be leveraged to verify the page status. Here’s an example:

protected void assertLoaded() {
  assertTrue(condition1, "Condition 1 failed");
  assertTrue(condition2, "Condition 2 failed");

protected boolean isLoadedBoolean() {
  try {
    return true;
  } catch (Error e) {
    return false;

This approach separates the boolean check from the assertion logic, making the code more readable and maintainable.

Alternative Design Using PageLoadCheckFailure

For a more detailed error reporting, you can create a class to capture the reasons for a page load failure. Here’s an implementation example:

public class PageLoadCheckFailure {
  public String reason;
  // other data

  public PageLoadCheckFailure(String reason) {
    this.reason = reason;

  public String getReason() {
    return reason;

protected PageLoadCheckFailure checkWhetherLoaded() {
  if (!condition1) {
    return new PageLoadCheckFailure("Condition 1 failed");
  if (!condition2) {
    return new PageLoadCheckFailure("Condition 2 failed");
  return null;

protected void assertLoaded() {
  PageLoadCheckFailure result = checkWhetherLoaded();
  if (result != null) {

protected boolean isLoadedBoolean() {
  return checkWhetherLoaded() == null;

This method provides more informative error messages, aiding in debugging and maintenance.


Refactoring your Selenium tests to use LoadableComponent effectively can significantly improve the reliability and maintainability of your test suite. By using assertions and detailed error reporting, you can create robust tests that ensure pages are fully loaded before interaction.

For further reading on advanced testing techniques and best practices, you can explore our documentation.

Enhance Your Testing with Repeato

If you’re looking for a no-code test automation tool that simplifies the process of creating, running, and maintaining automated tests, consider using Repeato. Repeato uses computer vision and AI to provide fast and efficient test automation for iOS and Android apps. Its intuitive interface allows you to set up and edit tests quickly, making it an excellent choice for quality assurance.

For more information on how Repeato can help streamline your testing process, visit our documentation page.

Like this article? there’s more where that came from!