10 Test Automation Design Patterns QA Must Know

Design patterns are essential in building robust and maintainable automation frameworks. Below are some common design patterns that are particularly useful for software testers when creating automation frameworks from scratch. Each pattern includes a brief explanation, an example, and key points to consider.

1. Singleton Pattern

Explanation: The Singleton Pattern ensures a class has only one instance and provides a global point of access to it. This is useful in automation frameworks where you need a single instance of WebDriver to manage browser interactions.

Example:

public class WebDriverManager {
    private static WebDriver driver;

    private WebDriverManager() { }

    public static WebDriver getDriver() {
        if (driver == null) {
            driver = new ChromeDriver();
        }
        return driver;
    }
}

Key Points:

Ensure the constructor is private to prevent multiple instantiations.
Lazy initialization can be used to delay the creation of the instance until it is needed.
Consider thread safety in multi-threaded test environments.

2. Page Object Model (POM)

Explanation: POM is a design pattern where each web page is represented as a class, and the various elements on the page are defined as variables within the class. Methods to interact with these elements are also defined within the class.

Example:

public class LoginPage {
    private WebDriver driver;

    @FindBy(id = "username")
    private WebElement usernameField;

    @FindBy(id = "password")
    private WebElement passwordField;

    @FindBy(id = "loginButton")
    private WebElement loginButton;

    public LoginPage(WebDriver driver) {
        this.driver = driver;
        PageFactory.initElements(driver, this);
    }

    public void login(String username, String password) {
        usernameField.sendKeys(username);
        passwordField.sendKeys(password);
        loginButton.click();
    }
}

Key Points:

Separate test logic from page-specific details.
Use PageFactory for initializing web elements.
Make sure each page class has methods representing user actions on that page.

3. Factory Pattern

Explanation: The Factory Pattern is used to create objects without specifying the exact class of object that will be created. This is useful for creating different types of WebDriver instances based on the browser type.

Example:

public class WebDriverFactory {
    public static WebDriver getDriver(String browserType) {
        if (browserType.equalsIgnoreCase("chrome")) {
            return new ChromeDriver();
        } else if (browserType.equalsIgnoreCase("firefox")) {
            return new FirefoxDriver();
        } else {
            throw new IllegalArgumentException("Unsupported browser type: " + browserType);
        }
    }
}

Key Points:

Define an interface or abstract class for common methods.
Implement concrete classes for specific variations.
Use the factory method to create instances based on input parameters.

4. Strategy Pattern

Explanation: The Strategy Pattern defines a family of algorithms, encapsulates each one, and makes them interchangeable. This is useful for defining various test data generation strategies.

Example:

public interface TestDataStrategy {
    String generate();
}

public class RandomDataStrategy implements TestDataStrategy {
    public String generate() {
        return "Random Data";
    }
}

public class FixedDataStrategy implements TestDataStrategy {
    public String generate() {
        return "Fixed Data";
    }
}

public class TestDataContext {
    private TestDataStrategy strategy;

    public void setStrategy(TestDataStrategy strategy) {
        this.strategy = strategy;
    }

    public String executeStrategy() {
        return strategy.generate();
    }
}

Key Points:

Define a strategy interface with a common method.
Implement different strategies based on the interface.
Use a context class to switch between strategies dynamically.

5. Decorator Pattern

Explanation: The Decorator Pattern allows behavior to be added to an individual object, dynamically, without affecting the behavior of other objects from the same class. This is useful for adding additional capabilities to WebDriver instances.

Example:

public class WebDriverDecorator implements WebDriver {
    protected WebDriver driver;

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

    public void get(String url) {
        driver.get(url);
        // Additional logging
        System.out.println("Navigated to " + url);
    }

    // Implement other WebDriver methods, delegating to the wrapped driver
}

Key Points:

Ensure the decorator class implements the same interface as the wrapped class.
Use composition to hold an instance of the decorated class.
Extend functionality by adding new behavior before or after delegating to the original method.

6. Observer Pattern

Explanation: The Observer Pattern defines a one-to-many dependency between objects so that when one object changes state, all its dependents are notified and updated automatically. This is useful for event handling and logging.

Example:

public interface TestObserver {
    void update(String eventType);
}

public class LoggerObserver implements TestObserver {
    public void update(String eventType) {
        System.out.println("Logging event: " + eventType);
    }
}

public class TestSubject {
    private List<TestObserver> observers = new ArrayList<>();

    public void addObserver(TestObserver observer) {
        observers.add(observer);
    }

    public void notifyObservers(String eventType) {
        for (TestObserver observer : observers) {
            observer.update(eventType);
        }
    }

    public void runTest() {
        // Test logic
        notifyObservers("Test Started");
        // More test logic
        notifyObservers("Test Finished");
    }
}

Key Points:

Define a subject that maintains a list of observers.
Allow observers to register and unregister themselves with the subject.
Notify all observers of state changes by calling their update methods.

7. Builder Pattern

Explanation: The Builder Pattern is used to construct a complex object step by step. It allows you to create different types and representations of an object using the same construction process.

Example:

public class TestData {
    private String username;
    private String password;

    public static class Builder {
        private String username;
        private String password;

        public Builder setUsername(String username) {
            this.username = username;
            return this;
        }

        public Builder setPassword(String password) {
            this.password = password;
            return this;
        }

        public TestData build() {
            TestData data = new TestData();
            data.username = this.username;
            data.password = this.password;
            return data;
        }
    }
}

Key Points:

Use a nested static builder class.
Provide methods to set each property.
Include a build method to return the final constructed object.

8. Command Pattern

Explanation: The Command Pattern encapsulates a request as an object, thereby allowing for parameterization of clients with queues, requests, and operations. This is useful for implementing undo and redo functionality in test automation.

Example:

public interface Command {
    void execute();
}

public class ClickCommand implements Command {
    private WebElement element;

    public ClickCommand(WebElement element) {
        this.element = element;
    }

    public void execute() {
        element.click();
    }
}

public class CommandInvoker {
    private List<Command> commandHistory = new ArrayList<>();

    public void executeCommand(Command command) {
        command.execute();
        commandHistory.add(command);
    }
}

Key Points:

Define a command interface with an execute method.
Implement concrete command classes for specific actions.
Use an invoker class to execute and keep track of commands.

9. Template Method Pattern

Explanation: The Template Method Pattern defines the skeleton of an algorithm in a method, deferring some steps to subclasses. This is useful for defining a common test execution flow with specific variations in subclasses.

Example:

public abstract class TestTemplate {
    public void runTest() {
        setup();
        execute();
        teardown();
    }

    protected abstract void setup();
    protected abstract void execute();
    protected abstract void teardown();
}

public class LoginTest extends TestTemplate {
    protected void setup() {
        System.out.println("Setup for login test");
    }

    protected void execute() {
        System.out.println("Executing login test");
    }

    protected void teardown() {
        System.out.println("Teardown for login test");
    }
}

Key Points:

Define a template method with the common algorithm structure.
Define abstract methods for steps that will be implemented by subclasses.
Ensure subclasses provide concrete implementations for abstract methods.

10. Proxy Pattern

Explanation: The Proxy Pattern provides a surrogate or placeholder for another object to control access to it. This is useful for implementing lazy initialization, logging, or access control in test automation.

Example:

public interface WebDriver {
    void get(String url);
    // Other WebDriver methods
}

public class RealWebDriver implements WebDriver {
    public void get(String url) {
        System.out.println("Navigating to " + url);
    }
    // Implement other WebDriver methods
}

public class WebDriverProxy implements WebDriver {
    private RealWebDriver realWebDriver;

    public void get(String url) {
        if (realWebDriver == null) {
            realWebDriver = new RealWebDriver();
        }
        System.out.println("Logging: Navigating to " + url);
        realWebDriver.get(url);
    }
    // Implement other WebDriver methods
}

Key Points:

Implement the same interface in both the real object and the proxy.
Use the proxy to add additional behavior such as logging or access control.
Ensure the proxy controls access to the real object.

By leveraging these design patterns, software testers can build scalable, maintainable, and robust automation frameworks. Keep these patterns in mind and choose the appropriate ones based on your specific needs and requirements.