Automation with Java & Selenium

You can articulate the software testing lifecycle, distinguish manual verification from test automation, and select the right test cases for automation.

1. The software testing lifecycle90 min
   • STLC phases
   • test planning
   • defect lifecycle
   • requirements traceability matrix
   • test closure reports
2. Manual versus automated testing90 min
   • ROI of automation
   • regression overhead
   • flaky tests
   • exploratory testing limits
   • execution frequency analysis
3. When and what to automate90 min
   • automation pyramid
   • stable vs volatile features
   • risk assessment
   • repetitive execution criteria
   • automation feasibility audit
4. Automation frameworks overview90 min
   • modular frameworks
   • data-driven design
   • keyword-driven design
   • hybrid frameworks
   • behavior-driven architecture
5. The automation tester's toolkit90 min
   • IDE setup with IntelliJ IDEA
   • build tools with Maven
   • version control with Git init
   • terminal commands for testers
   • environment path configuration
6. Test metrics and quality gates90 min
   • defect density
   • test coverage percentage
   • pass/fail ratios
   • execution duration tracking
   • quality gate thresholds

Hands-on project: Write a test evaluation matrix document categorizing 25 manual test cases into automated regression, smoke, and manual-only buckets with justification.

You can write object-oriented Java programs using collections, inheritance, and exception handling tailored for test automation scripts.

1. Variables, data types and control flow120 min
   • primitives
   • conditionals
   • for and while loops
   • switch expressions
   • type casting
2. Object-oriented programming120 min
   • classes and objects
   • constructors
   • encapsulation and getters/setters
   • this keyword
   • access modifiers
3. Inheritance, polymorphism and interfaces120 min
   • extends keyword
   • method overriding
   • interface contracts
   • super keyword
   • abstract classes
4. Collections and generics120 min
   • ArrayList
   • HashMap
   • Iterator and generics
   • HashSet operations
   • List vs Set trade-offs
5. Exception handling and file I/O120 min
   • try-catch-finally
   • throws keyword
   • FileReader and Properties classes
   • custom runtime exceptions
   • try-with-resources
6. Java memory model and debugging120 min
   • heap and stack allocation
   • garbage collection basics
   • breakpoint debugging in IntelliJ
   • NullPointerException diagnosis
   • stack trace analysis

Hands-on project: Build a command-line utility in Java that parses configuration properties files and manages test data using HashMaps and custom exception handlers.

You can initialize WebDriver instances, control browser sessions, and execute foundational navigation commands across multiple browsers.

1. Selenium architecture and components90 min
   • JSON Wire Protocol
   • W3C WebDriver protocol
   • browser drivers
   • Selenium server vs client libs
   • driver binary management
2. WebDriver and browser drivers90 min
   • ChromeDriver setup
   • WebDriver interface
   • browser options and capabilities
   • FirefoxDriver configuration
   • EdgeDriver initialization
3. Launching and controlling browsers90 min
   • headless mode
   • window sizing
   • maximize and fullscreen
   • manage().window().setPosition()
   • incognito and private modes
4. Your first automation script90 min
   • Maven dependencies for selenium-java
   • WebDriver instantiation
   • assertions on page titles
   • driver.quit() vs driver.close()
   • handling driver version mismatches
5. Browser navigation and commands90 min
   • get() vs navigate().to()
   • back, forward, refresh
   • getPageSource()
   • getCurrentUrl()
   • managing browser history
6. Driver service management90 min
   • ChromeDriverService builder
   • setting driver log output files
   • passing custom arguments to browser
   • timeouts configuration on driver
   • handling port allocation failures

Hands-on project: Create a standalone Maven project that launches Chrome via WebDriver, navigates to a staging URL, validates page titles, and closes the session cleanly.

You can locate complex web elements using advanced XPath and CSS selectors while applying robust explicit waits to eliminate flaky tests.

1. Locators: id, name, XPath and CSS120 min
   • By.id
   • By.name
   • relative XPath
   • CSS selectors
   • XPath axes (following-sibling, ancestor)
2. Finding single and multiple elements120 min
   • findElement()
   • findElements()
   • StaleElementReferenceException handling
   • NoSuchElementException debugging
   • list size verification
3. Clicks, typing and form controls120 min
   • sendKeys()
   • click()
   • clear()
   • getAttribute()
   • getText() and getCssValue()
4. Dropdowns, checkboxes and radio buttons120 min
   • Select class
   • deselect methods
   • handling bootstrap dropdowns
   • checking selected states with isSelected()
   • multi-select interactions
5. Implicit, explicit and fluent waits120 min
   • WebDriverWait
   • ExpectedConditions
   • FluentWait polling frequency
   • ignoring specific exceptions
   • avoiding Thread.sleep anti-patterns
6. Robust locator strategies in dynamic apps120 min
   • handling auto-generated IDs
   • using contains() and starts-with() in XPath
   • CSS pseudo-classes for unstable DOMs
   • maintaining locator health
   • debug tools for selector verification

Hands-on project: Automate a multi-step user registration form on a test site handling dropdowns, checkboxes, and explicit waits for asynchronous loading states.

You can handle complex UI scenarios including browser alerts, nested iframes, multiple windows, drag-and-drop actions, and file uploads.

1. Alerts, frames and windows90 min
   • Alert interface
   • switchTo().frame()
   • getWindowHandles()
   • switching back to default content
   • handling authentication popups
2. The Actions class: mouse and keyboard90 min
   • moveToElement()
   • dragAndDrop()
   • keyUp and keyDown
   • contextClick() and doubleClick()
   • composite action building
3. JavaScriptExecutor90 min
   • executeScript()
   • scrolling into view
   • clicking obscured elements
   • modifying DOM element styles
   • checking document.readyState
4. Screenshots and capturing failures90 min
   • TakesScreenshot interface
   • FileUtils
   • timestamping image files
   • capturing full-page screenshots
   • attaching images to log streams
5. File upload and download90 min
   • sendKeys for file upload
   • ChromeOptions download directory configuration
   • verifying file existence
   • handling OS-level file dialogs with AutoIt
   • setting download preferences in browser profile
6. Shadow DOM and web components90 min
   • getShadowRoot() API
   • piercing shadow boundaries
   • interacting with custom elements
   • debugging shadow DOM structures
   • handling nested shadow roots

Hands-on project: Write an automation script handling a nested iframe login modal, switching window tabs, performing a drag-and-drop action via Actions, and capturing a failure screenshot.

You can structure test suites with TestNG annotations, assertions, groups, parameterization, and parallel execution.

1. TestNG annotations and lifecycle90 min
   • @Test
   • @BeforeMethod
   • @AfterClass
   • execution order control
   • @BeforeSuite and @AfterSuite
2. Assertions and soft assertions90 min
   • Assert.assertEquals
   • SoftAssert class
   • assertAll()
   • failure collection strategies
   • custom error messages in assertions
3. Groups, priorities and dependencies90 min
   • groups attribute
   • priority values
   • dependsOnMethods
   • alwaysRun attribute
   • excluding groups in XML
4. Parameterization and data providers90 min
   • @Parameters
   • testng.xml parameters
   • @DataProvider
   • data provider indices
   • parallel data provider execution
5. Parallel execution and reports90 min
   • parallel=tests attribute
   • thread-pool size
   • default TestNG emailable reports
   • thread safety with ThreadLocal WebDriver
   • resolving race conditions in parallel runs
6. TestNG listeners and interceptors90 min
   • ITestListener interface
   • onTestFailure and onTestSuccess hooks
   • IRetryAnalyzer for flaky tests
   • IAnnotationTransformer for dynamic config
   • listener registration in XML

Hands-on project: Configure a TestNG XML suite file running 20 test cases in parallel across two priority groups with soft assertions and test listeners.

You can design maintainable hybrid test frameworks using the Page Object Model, Page Factory, and Maven project structures.

1. Why frameworks matter120 min
   • code duplication
   • maintenance overhead
   • separation of concerns
   • test suite scalability
   • reducing test flakiness
2. The Page Object Model and Page Factory120 min
   • @FindBy annotation
   • PageFactory.initElements
   • encapsulating page actions
   • returning page objects from action methods
   • fluent page design pattern
3. Reusable utilities and base classes120 min
   • BaseTest setup
   • WebDriver thread safety
   • wait helper methods
   • common browser actions abstraction
   • configuration loader utility
4. Building a hybrid framework120 min
   • combining POM and TestNG
   • listener implementation
   • config reader utility
   • logging with Log4j2
   • managing test run properties
5. Project structure with Maven120 min
   • pom.xml dependencies
   • src/main/java vs src/test/java
   • maven surefire plugin configuration
   • profiles for environment switching
   • managing artifact versions
6. Framework code review and refactoring120 min
   • identifying tight coupling
   • extracting magic strings to constants
   • improving encapsulation
   • clean code principles in test suites
   • static analysis with Checkstyle

Hands-on project: Refactor raw test scripts into a Maven project implementing the Page Object Model with reusable BaseClass setup and teardown methods.

You can externalize test data using Apache POI Excel sheets and properties files to drive parameterized test runs.

1. Externalizing test data90 min
   • hardcoded data anti-pattern
   • JSON vs Excel vs Properties
   • data decoupling
   • managing sensitive test credentials
   • environment-specific data sets
2. Reading from Excel with Apache POI90 min
   • XSSFWorkbook
   • XSSFSheet
   • Row and Cell iterators
   • handling numeric and string cell types
   • writing results back to Excel sheets
3. Properties and configuration files90 min
   • config.properties
   • loading environment URLs
   • credentials management
   • handling missing property keys
   • overriding properties via CLI flags
4. Data providers in practice90 min
   • Object[][] return type
   • mapping excel rows to dataprovider
   • dynamic data loading
   • filtering datasets at runtime
   • handling large test matrices
5. Parameterized test suites90 min
   • running tests across multiple datasets
   • data-driven reporting
   • handling empty cells
   • parameterizing test groups in XML
   • dynamic test case generation
6. JSON and CSV data integration90 min
   • Jackson library for JSON parsing
   • mapping JSON arrays to POJOs
   • OpenCSV for lightweight tabular data
   • comparing Excel vs JSON approaches
   • deserializing complex test payloads

Hands-on project: Implement an Apache POI utility reader that feeds user login test datasets from an Excel spreadsheet into a TestNG DataProvider.

You can write behavior-driven feature files in Gherkin syntax and implement Java step definitions executing Selenium actions.

1. Behaviour-driven development concepts90 min
   • BDD principles
   • collaboration between dev and QA
   • living documentation
   • three amigos meetings
   • ubiquitous language in testing
2. Gherkin and feature files90 min
   • Given-When-Then syntax
   • Background and Scenario Outline
   • Examples tables
   • tags for filtering execution (@smoke, @regression)
   • feature file organization structure
3. Step definitions90 min
   • Cucumber annotations (@Given, @When, @Then)
   • regular expressions in steps
   • passing parameters
   • transformer functions for custom types
   • avoiding duplicate step definitions
4. Cucumber with Selenium90 min
   • TestRunner class
   • glue code configuration
   • hook annotations (@Before, @After)
   • sharing state between step definitions
   • pico-container dependency injection in Cucumber
5. Cucumber reports90 min
   • html and json plugins
   • pretty formatter
   • cucumber reporting plugins
   • embedding screenshots on step failure
   • publishing reports to CI dashboards
6. Advanced Cucumber patterns90 min
   • parallel execution of Cucumber scenarios
   • rerunning failed scenarios with txt plugins
   • abstracting page objects into step definitions
   • data tables in Gherkin steps
   • transforming data tables into lists and maps

Hands-on project: Create a Cucumber feature file for an e-commerce checkout flow with Scenario Outlines and implement matching step definition methods.

You can test RESTful web services, validate JSON payloads, parse response headers, and chain API requests with RestAssured.

1. API testing fundamentals for SDETs90 min
   • REST architecture principles
   • HTTP methods and status codes
   • request and response structures
   • headers and query parameters
   • authentication types (Bearer, Basic, OAuth2)
2. Getting started with RestAssured90 min
   • RestAssured Maven dependency
   • given(), when(), then() syntax
   • logging request and response details
   • specifying base URI and base path
   • setting request headers and content type
3. Validating responses and JSONPath90 min
   • statusCode() and body() assertions
   • Hamcrest matchers (equalTo, hasItem)
   • JSONPath expression extraction
   • extracting primitive values from response
   • validating array sizes and attributes
4. Request specification and serialization90 min
   • RequestSpecification and ResponseSpecification
   • reusable spec builders
   • serialization with POJOs and Jackson
   • deserialization of JSON responses into Java objects
   • handling payload payloads cleanly
5. Integrating API checks into UI tests90 min
   • pre-conditioning test data via API before UI run
   • database state verification via API
   • hybrid test flows combining RestAssured and Selenium
   • cleaning up test artifacts via API calls
   • token generation and session sharing
6. API test reporting and error handling90 min
   • handling intermittent API failures
   • logging request payloads on test failure
   • integrating RestAssured with TestNG listeners
   • validating response schemas with JSON Schema Validator
   • performance assertions on response times

Hands-on project: Build an API test suite using RestAssured validating authentication endpoints, CRUD operations, response schemas, and status codes.

You can configure Selenium Grid for distributed cross-browser testing and integrate your test suite into a Jenkins CI pipeline with Extent reports.

1. Selenium Grid architecture90 min
   • Hub and Node model
   • Standalone mode
   • Dockerized Selenium Grid containers
   • Grid 4 distributed topology
   • node registration and health checks
2. Cross-browser and parallel testing90 min
   • DesiredCapabilities
   • RemoteWebDriver
   • cross-browser test execution
   • targeting browser versions in Grid
   • scaling sessions across containers
3. Integrating with Jenkins90 min
   • Jenkins freestyle and pipeline jobs
   • Maven installation in Jenkins
   • build triggers
   • managing build parameters
   • workspace cleanup plugins
4. Running tests in CI/CD90 min
   • headless execution in Linux containers
   • handling CI timeouts
   • console output logging
   • maven surefire report publishing
   • failure notifications to Slack or email
5. Extent and rich reporting90 min
   • ExtentReports setup
   • attaching screenshots to logs
   • publishing HTML reports in CI artifacts
   • spark reporter configuration
   • customizing report metadata and logs
6. Dockerizing test execution environments90 min
   • Dockerfile for test runners
   • Docker Compose for local Grid setup
   • volume mounting test reports out of containers
   • network bridging between test container and app under test
   • optimizing base image size for CI speed

Hands-on project: Write a Jenkinsfile that checks out your test repo, triggers Maven test execution in parallel on Selenium Grid, and archives Extent HTML reports.

You can maintain enterprise automation suites by debugging flaky tests, implementing robust logging, managing test debt, and optimizing execution speed.

1. Diagnosing and eliminating test flakiness90 min
   • root causes of flaky tests
   • race conditions in AJAX apps
   • network latency handling
   • asynchronous DOM updates
   • isolation of test state
2. Advanced logging and observability for QA90 min
   • Log4j2 configuration appenders
   • structured log formats
   • tracing test execution paths
   • capturing browser console logs
   • network traffic logging with BrowserMob proxy
3. Test suite performance optimization90 min
   • parallel thread count tuning
   • minimizing browser launch overhead
   • reusing driver sessions safely
   • headless execution benchmarks
   • optimizing selector evaluation speed
4. Test maintenance and debt management90 min
   • handling frequent UI redesigns
   • locating broken selectors efficiently
   • refactoring test code duplication
   • managing obsolete test cases
   • version control branching strategies for QA
5. Security and compliance in test automation90 min
   • handling test secrets securely
   • masking PII in test logs and reports
   • running automated security scans in CI
   • dependency vulnerability auditing with OWASP
   • compliance requirements for test environments
6. Test metrics dashboards and reporting90 min
   • aggregating test results across builds
   • tracking pass rate trends over time
   • identifying top failing test cases
   • integration with Allure reporting
   • publishing quality dashboards to stakeholders

Hands-on project: Refactor a flaky test suite by implementing intelligent retry mechanisms, explicit wait wrappers, and performance profiling to reduce execution time by 30%.

You can scale test automation across multiple scrum teams, manage shared test environments, and establish enterprise QA governance standards.

1. Scaling automation across multiple squads90 min
   • monolithic vs modular test repo structures
   • publishing internal test utility libraries
   • managing shared page object repositories
   • code ownership and pull request reviews for QA
   • coordinating cross-team releases
2. Test environment management90 min
   • staging vs QA vs ephemeral environments
   • data seeding and cleanup strategies
   • handling environment downtime in CI
   • service virtualization with WireMock
   • mocking third-party dependencies
3. Shift-left testing and developer collaboration90 min
   • incorporating unit and integration tests
   • code reviews of test code by developers
   • running automated sanity checks on pull requests
   • shared definition of done
   • defect prevention workshops
4. QA governance and compliance90 min
   • audit trails for test runs
   • regulatory compliance in automated suites
   • traceability from requirement to test execution
   • standardizing framework templates across teams
   • enforcing coding standards with linters
5. Cost optimization in cloud test execution90 min
   • managing cloud Grid infrastructure costs
   • spot instances for Jenkins worker nodes
   • optimizing CI build durations
   • container resource allocation tuning
   • ROI analysis of automation scaling
6. Building a culture of quality90 min
   • quality advocacy in engineering teams
   • root cause analysis retrospectives
   • sharing test automation knowledge
   • mentoring manual testers into automation
   • continuous improvement of testing practices

Hands-on project: Design an enterprise QA strategy document defining branching models, test environment provisioning, gatekeeper policies, and cross-team code ownership.

You can build and deploy a complete production-grade hybrid automation framework integrating POM, TestNG, Cucumber BDD, and CI pipelines.

1. Design a complete hybrid framework90 min
   • architecture blueprint
   • folder structuring
   • design pattern selection
   • component wiring review
   • scalability planning
2. Combine POM, TestNG, data-driven and BDD90 min
   • integrating Cucumber runners with TestNG
   • unified reporting
   • robust assertion strategies
   • cross-module integration testing
   • end-to-end user journey validation
3. Run cross-browser in Selenium Grid90 min
   • remote execution setup
   • parallel thread tuning
   • environment configuration
   • grid stability verification
   • handling distributed node failures
4. Integrate with a CI pipeline90 min
   • Jenkins pipeline script finalization
   • artifact archiving
   • failure alert configuration
   • automated trigger on git push
   • pipeline status badge embedding
5. Portfolio, resume, mock interviews and career prep90 min
   • SDET interview question walkthrough
   • live coding practice
   • GitHub portfolio polish
   • resume positioning for automation roles
   • behavioral interview preparation
6. Final project review and defense90 min
   • code walkthrough with mentor
   • architecture defense Q&A
   • performance audit of test suite
   • documentation review
   • graduation and certification sign-off

Hands-on project: Submit a complete GitHub repository containing a hybrid automation framework with 30+ test cases, BDD scenarios, data-driven Excel inputs, CI/CD pipeline configuration, and portfolio documentation.