Java Design Patterns & Devops to build Selenium Framework

Introduce the single responsibility principle (SRP) and its one-class, one-responsibility rule for decoupled, maintainable code; contrasts with page object pattern and separate flight and hotel logic.

Break the page object pattern into subcomponents like navigation bar and footer navigation within a Maven travel homepage. Delegate responsibilities to subclasses and enable scoped selenium searches.

Build a selenium framework with abstract components and a custom find element that restricts searches to a page section, following the single responsibility pattern and reusable locators for footer scope.

Create custom find elements to narrow the execution search in a selenium framework by passing the driver and section element through constructors, then target the footer and click flights.

Organize the selenium framework by applying the single responsibility design pattern, splitting the travel homepage into main page objects, page components, and abstract components, with refactoring and a demo test.

Apply the single responsibility design pattern to selenium tests by wiring the driver through the travel homepage and footer navigation, using constructors to bind the driver and inspect flight attributes.

Demonstrates applying the single responsibility pattern to reuse navigation bar and footer components within a Selenium framework, using abstract components, section elements, and custom find methods for reliable, scoped locators.

Review SRP principles and show implementing single responsibility by separating page components and navigation into distinct classes, enabling decoupled code and scoped element finding in the Selenium framework.

Introduces the strategy design pattern to select an algorithm at runtime for checking one way, roundtrip, and multi city flight availability, while avoiding breaking the single responsibility principle.

Apply the strategy design pattern by defining a web driver interface with Chrome and Firefox drivers, and implement check availability in multi trip and roundtrip to search flights.

Learn to implement a runtime flight booking strategy using a common interface; set a strategy (multi trip, round trip, or one way) and route check availability to the correct class.

Execute tests by dynamically selecting roundtrip or multi trip strategies at runtime using the strategy design pattern, driven by a common interface for flight availability.

Implement a real algorithm for flight check availability in a round-trip flow using selenium, applying page object model and strategy design pattern to manage origin, destination, and options.

Design robust Selenium page objects by inheriting abstract components and implementing interfaces, then apply a strategy pattern to manage round-trip and multi-city flows with reliable dropdowns and popups.

Discover how the factory design pattern creates objects via a factory method and returns a common interface to support multi trip and round trip strategies.

Apply the execute around pattern to create a make state ready pre request for Selenium tests, then pass the actual action via a consumer for reusable boilerplate handling.

Learn to implement the execute around pattern in a Selenium Java framework, applying pre and post actions, prerequisites, and waits via an abstract component to minimize reusable code.

Replace hard-coded values with a hash map in the framework and update the interface contract to pass reservation details such as origin and destination.

Parameterize tests using a hash map data provider to run the same test iteratively with multiple reservation detail datasets, including loading data from json.

Parameterize end-to-end tests with multiple data sets using a data provider and hash map, driven by a strategy, with global chrome driver initialization and before/after test cleanup.

Drive test data from external JSON files into hash map lists for selenium tests. Learn to use JSON over Excel, parse API responses, and build data providers with Jackson dependencies.

Convert the JSON file content to a string using Apache Commons IO FileUtils. Then marshal the string to a list of hash maps using ObjectMapper.readValue with a TypeReference.

Build a data-driven selenium framework by implementing a json-driven data reader, extracting data into a list of hash maps, and feeding multiple data sets via a test data provider.

Address the challenges of maintaining automation framework across multiple teams and repositories. Learn to implement a single organization level core framework with shared page objects, test cases, and Maven integration.

Create a core automation framework jar with mvn clean install, publish to the Maven repository, and reuse it in new repos by declaring groupId, artifactId, and version in the pom.xml.

Import the core automation framework, update page objects, and manage maven dependencies via pom.xml; then build the jar and run tests in your own repository.

This lecture explains JFrog as an artifact management tool, its Maven integration, and how to push, deploy, and pull snapshot jars to a central Artifactory repository for team reuse.

Configure jfrog as a universal artifact management service, create a maven repository and snapshot local repo, and secure maven settings with an encrypted api key.

Deploy the framework artifact to JFrog with the Maven deploy command, publishing a 1.94 snapshot and configuring pom.xml and settings.xml for publish and authentication.

Learn how to access the Artifactory via JFrog to fetch the 1.94 snapshot, update your pom.xml distribution management, and deploy snapshots so tests run from the core automation framework.

Learn to implement continuous integration for a design pattern framework by automating artifact deployment from GitHub to JFrog using a Jenkins job triggered by code pushes, eliminating manual deployments.

Set up a freestyle Jenkins project linked to a GitHub repository on the main branch, using Maven deploy to the artifact repository, with automatic triggers for continuous integration on push.

Connect GitHub to Jenkins by configuring a public webhook, enable GitHub hook trigger, and use Socket XP to expose private Jenkins for automatic job triggers upon commits.