SDET: Design Patterns With Selenium [Java + Hands-On]

Apply the single responsibility principle by giving a class a purpose to minimize testing and maintenance; leverage polymorphism and interfaces to keep components cohesive, loosely coupled, and avoid monolithic designs.

Learn a Selenium design pattern workflow: interact with search box, suggestions, and navigation to results page, while applying the single responsibility principle with abstract component that provides an isDisplayed check.

Build a search widget component for a Google page by using a webdriver, page factory, and explicit waits, then enter keywords into the 'Q' text box.

Implement the result state component by extending the abstract component, locating the stat by its ID, waiting for display, and exposing get stat to return the element's text.

Implement a Google result page using a page object model with search widget, search suggestion, and navigation bar; initialize via page factory and create main and result pages.

Create a base test in Java that initializes a WebDriver, sets up before and after test hooks, and shares a protected driver across page object tests for Firefox or Chrome.

Refactor your selenium design by organizing page objects into main, result, and common packages, centralizing shared components like the search widget, microphone, and navigation bar in a common package.

Explore the difference between the single responsibility principle and design patterns, explaining how SRP focuses on small, single-purpose classes, while design patterns define interaction protocols between classes.

Implement the google english page by extending the abstract google page, using the factory pattern with page factory and selenium java, and waiting for search results.

Explore a simple HTML example that demonstrates the strategy design pattern for a checkout page with multiple payment options—credit card, net banking, PayPal, and future options.

Introduce the strategy pattern to replace complex if-else in a payment flow, moving to component-based page objects for credit card, net banking, and PayPal.

Implement the strategy pattern for the payment screen by building a page object and modular components for user information and the order, following the single responsibility principle.

The strategy pattern, a behavioral pattern, changes a component's behavior at runtime by substituting different payment options on the payment screen, as in swapping engines.

Explore how factory creates objects (creational) and how strategy changes behavior (behavioral), using car engines and multiple payment options as examples.

Explore the template method design pattern, a special case of the factory pattern, and see how shared steps—from launching a site to entering payment details—apply across tasks using page objects and tests.

See how the template method pattern standardizes a purchase workflow by outlining the same steps—launch, search, select, land on the product description, extract price—and automate with a template.

Apply the template method to build an Amazon shopping flow by extending the shopping template, implementing search, select, and price extraction with Selenium WebDriver, waits, and page factory.

Explore how the template method pattern manages a large, multi-page shopping workflow by delegating page object creation to a shopping template, with Amazon and eBay implementations.

Integrate the order component proxy into the page object by replacing the real order with a proxy, using an interface and the driver, to test it.

Leverage the proxy object and a proxy package to run the same tests, highlighting page object design, and compare behavior across QA and production via system properties.

discover how a proxy object centralizes access on the payment screen, delegating to the real object in lower environments and bypassing it in higher ones, enabling controlled access and logging.

Apply the execute method pattern to a three-frame form, with behind-the-scenes switching, enabling data entry in any frame and in any order via page objects.

Implement the execute around method by building a main page object with three frame components (frame A, frame B, frame C), initialized via page factory and ready for frame switching.

Apply the execute around method pattern in Selenium to manage frame switching for frames A, B, and C. Use lambdas to define frame actions and automatically return to default content.

Apply the decorator pattern to a payment page scenario with coupon, partial promo code, and credit card options, and design page objects and tests.