Back to Courses
FOR SELENIUM PROFESSIONALS — ADVANCED LEVEL

Advanced Selenium with Java

Master enterprise-grade frameworks using Advanced TestNG, Design Patterns, Extent Reports, Log4J, JavascriptExecutor, Selenium Grid, Docker, Jenkins CI/CD, Keyword Driven Framework — and deliver a complete live project.

35+
Days of Training
15
Modules
100+
Topics Covered
Live
Project

 Who Is This Course For?

This course is designed for engineers who have completed a core Selenium with Java course and are ready to work at a professional, enterprise level. You will build a complete Automation Framework integrating advanced TestNG features, multiple design patterns, Selenium Grid, Docker, Jenkins CI/CD, and a real-world project — the way top QA teams actually work.

Advanced TestNG & Design Patterns Extent Reports & Log4J Selenium Grid & Docker Jenkins CI/CD Pipeline Keyword Driven Framework Live Project — POS Application

🚀 Course Progression

Each module builds toward a production-grade automation framework used in real companies.

1Advanced TestNG
2Patterns & Reports
3Grid & CI/CD
4Live Project
🏆Senior QA!
MODULE 01  Advanced TestNG — Annotations, Data Providers & Factories
Why this matters: Most testers use only basic TestNG. Mastering @DataProvider, @Factory, and dependsOnMethods lets you run smarter, data-driven, and highly controlled test suites — skills that immediately impress in interviews.
Annotations & Execution Control
  • Full annotation lifecycle — @BeforeSuite, @BeforeTest, @BeforeClass, @BeforeMethod, @AfterMethod, @AfterClass, @AfterSuite
  • invocationCount — running a test method multiple times; constraints and valid use cases
  • priority — default value 0; negative values allowed; alphabetical tie-breaking
  • dependsOnMethods — precedence over priority when both are set
  • enabled=false vs alwaysRun=true — controlling test skipping within groups
  • Master suite XML — combining multiple testng.xml files into one run using <suite-files>
DataProvider — All Return Types
  • Object[] — single-parameter dataset; Object[][] — multi-row multi-column dataset
  • Iterator<Object[]> — lazy loading for large datasets without loading everything into memory
  • Why Map is not a valid @DataProvider return type
Assert, Groups & @Factory
  • Assert vs SoftAssert — fail-fast vs. collect-all-failures strategy
  • @Test(groups) — smoke, regression, sanity; running specific groups from testng.xml
  • @Parameters — passing values from testng.xml into test methods at runtime
  • @Factory — dynamically generating multiple test class instances from a single class
  • Running TestNG programmatically via TestNG and XmlSuite classes — no XML needed
MODULE 02  Dependency Injection & Java Reflection
Why this matters: Dependency Injection is how enterprise frameworks avoid duplicating browser setup across dozens of test classes. Understanding java.lang.reflect makes you stand out in senior-level framework design interviews.
Topics Covered
  • What Dependency Injection means — providing objects to a class rather than letting it create them
  • Injecting WebDriver into test classes via constructor or method parameters
  • java.lang.Class, java.lang.reflect.Method — inspecting and invoking methods at runtime
  • Running test methods programmatically using reflection — no hardcoded test names
  • Writing test results back to an Excel file after each test via injected utility classes
  • DI vs. static WebDriver — when to use each approach in real projects
MODULE 03  Listeners, IRetryAnalyzer & Screenshot on Failure
Why this matters: Flaky tests cost teams hours of manual re-runs. Implementing IRetryAnalyzer and ITestListener at the framework level means your suite handles failures automatically — a hallmark of a production-ready framework.
Topics Covered
  • IRetryAnalyzer — implementing retry(ITestResult) to auto-re-run failed tests up to a configurable limit
  • ITestListener — hooking into onTestFailure(), onTestStart(), onTestSuccess() lifecycle events
  • Taking a screenshot on failure using ITestResult + TakesScreenshot + FileUtils.copyFile()
  • Attaching failure screenshots automatically to ExtentReports via Base64 encoding
  • Reporter.log() — adding custom step messages visible in the TestNG HTML report
  • Registering listeners via @Listeners annotation or the <listeners> block in testng.xml
MODULE 04  Design Patterns — Singleton, Factory & Decorator
Why this matters: Design patterns are asked in virtually every senior QA interview. Learning to implement and explain them with real Selenium examples puts you ahead of 90% of candidates in the market.
Singleton Pattern
  • Private constructor + static method = one WebDriver instance for the entire test run
  • Preventing multiple browser launches when multiple test classes initialize the driver
Factory Pattern
  • DriverFactory class — returning ChromeDriver, FirefoxDriver, or EdgeDriver based on input parameter
  • Removing browser-specific if-else logic from individual test classes
Decorator Pattern
  • Selenium 3 — EventFiringWebDriver + implementing WebDriverEventListener
  • Selenium 4 — EventFiringDecorator wrapping WebDriver + WebDriverListener interface
  • Logging every click(), navigate().to(), and exception automatically through the listener
  • Choosing between extends AbstractWebDriverEventListener vs. implements WebDriverListener
MODULE 05  Advanced POM — @FindBy, @FindAll, @CacheLookup
Why this matters: Standard POM is just the beginning. Advanced annotations like @FindAll, @FindBys, and @CacheLookup make your page classes faster and more expressive — and interviewers notice the difference.
Topics Covered
  • @FindBy — declaring WebElement and List<WebElement> fields, initialized via PageFactory.initElements(driver, this)
  • @FindAll — locating elements matching any of multiple locators (OR logic)
  • @FindBys — locating elements matching all of multiple locators (AND / parent-child chaining)
  • @CacheLookup — caching the element reference after the first DOM lookup to improve performance
  • When @CacheLookup helps vs. when it breaks — dynamic elements, page refresh, AJAX updates
  • Comparing @FindAll vs @FindBys — logic difference and when to use each in real tests
MODULE 06  Screenshots — TakesScreenshot, AShot & Robot
Why this matters: Knowing three different screenshot approaches — and when each is appropriate — shows depth of knowledge. Most testers only know one method, and interviewers notice.
Topics Covered
  • TakesScreenshot — casting WebDriver and calling getScreenshotAs(OutputType.FILE) for full-page capture
  • Saving screenshots with FileUtils.copyFile() using timestamped filenames to avoid overwriting
  • WebElement.getScreenshotAs() — capturing just a specific element on the page (Selenium 4)
  • AShot library — full-page screenshots including content below the visible fold
  • Robot class (java.awt.Robot) — OS-level desktop screenshot using createScreenCapture(new Rectangle(Toolkit.getDefaultToolkit().getScreenSize()))
  • Capturing screenshots on failure via ITestListener.onTestFailure(ITestResult) — no test-level code needed
MODULE 07  JavascriptExecutor & Robot Class — Beyond Selenium's Limits
Why this matters: Some elements simply cannot be handled by standard Selenium — hidden inputs, custom widgets, OS-level dialogs. JavascriptExecutor and Robot are what professionals reach for when Selenium hits a wall.
JavascriptExecutor
  • Casting WebDriver to JavascriptExecutor and calling executeScript(String, Object...)
  • Scrolling by pixel: window.scrollBy(0, 500); scrolling to element: arguments[0].scrollIntoView()
  • Clicking elements that WebElement.click() cannot reach: arguments[0].click()
  • Setting input values via JS: arguments[0].value='text' for blocked input fields
  • Reading values: return arguments[0].value / return arguments[0].textContent
  • Limitations — bypasses user interaction validation; use carefully in real automation
Robot Class
  • Robot.mouseMove(x, y), mousePress(InputEvent.BUTTON1_DOWN_MASK), mouseRelease()
  • Robot.keyPress(KeyEvent.VK_ENTER) — keyboard simulation at OS level
  • Handling Windows file upload dialogs and OS pop-ups that Selenium cannot touch
  • Combining with StringSelection and Toolkit.getDefaultToolkit().getSystemClipboard() for clipboard operations
MODULE 08  Reporting & Logging — ExtentReports & Log4J
Why this matters: Professional testers don't just run tests — they produce shareable evidence. Rich HTML reports and structured log files let your team and stakeholders see exactly what was tested, what passed, and why something failed — with zero manual effort.
ExtentReports
  • Setting up ExtentSparkReporter and ExtentReports instance in a base class or listener
  • Creating ExtentTest nodes per test and logging .pass(), .fail(), .skip() with messages
  • Attaching Base64-encoded screenshots to reports on failure
  • Integrating with ITestListener for automatic lifecycle-driven reporting
  • Flushing reports at end of suite with extent.flush()
Log4J & Reporter
  • log4j2.xml / log4j.properties — configuring ConsoleAppender, FileAppender, and log patterns
  • LogManager.getLogger(ClassName.class) — logging at DEBUG, INFO, WARN, ERROR levels
  • Reporter.log() — embedding step-level messages directly into the TestNG HTML report
  • Reporter.getOutput(ITestResult) — reading Reporter messages to attach to ExtentReport
MODULE 09  Data Handling — Excel, Config, CSV, JSON & Database
Why this matters: Real projects store test data in many different formats. Knowing how to read Excel, config files, CSVs, JSON, and databases makes your framework flexible and environment-agnostic — a major differentiator in job interviews.
Excel — Apache POI
  • XSSFWorkbook, XSSFSheet, XSSFRow, XSSFCell — reading and writing .xlsx files
  • Converting Excel rows to Map<String, String> for use in @DataProvider
  • Writing test results (Pass/Fail/timestamp) back to Excel after each run
Property Files & CSV
  • java.util.Properties — loading key-value config (base URL, credentials) from .properties files
  • Apache Commons CSV — parsing CSV files into row/column collections for test data
JSON & Database
  • JSON data types — objects, arrays, strings, numbers, booleans, null
  • Parsing JSON with JSONObject / JSONArray or REST Assured's JsonPath
  • Connecting to MySQL using java.sql.DriverManager.getConnection(url, user, pass)
  • Statement, PreparedStatement, ResultSet — querying DB and comparing values to UI output
MODULE 10  Maven & Command Line Execution
Why this matters: Jenkins and other CI tools trigger test runs from the command line. If you can only run tests inside an IDE, you cannot work in a real CI/CD pipeline. This module makes your framework pipeline-ready.
Topics Covered
  • Running mvn test from the terminal — no IDE open, no manual steps
  • Passing parameters via -D system properties: mvn test -Dbrowser=chrome -Denv=staging
  • Reading System.getProperty("browser") inside test code and inside testng.xml using ${browser}
  • Selecting specific TestNG suites via maven-surefire-plugin <suiteXmlFile> config
  • Running a single test class or method: mvn -Dtest=LoginTest#verifyLogin test
  • Full parameter chain: Jenkins build param → pom.xml → testng.xml → @Parameters → test method
MODULE 11  Selenium Grid & Cloud Testing — SauceLabs
Why this matters: Parallel execution across multiple browsers and machines is how enterprise teams cut test times from hours to minutes. Selenium Grid and cloud platforms are standard tools at any mature QA organization.
Selenium Grid
  • Standalone mode — single-node Grid using java -jar selenium-server.jar standalone
  • Hub & Node — registering remote machines to a central Hub for distributed execution
  • Connecting via RemoteWebDriver using Hub URL and ChromeOptions / FirefoxOptions
  • Parallel execution in testng.xml using parallel="tests" and thread-count
  • Thread-safe driver management using ThreadLocal<WebDriver> to avoid cross-thread interference
Cloud — SauceLabs
  • Configuring RemoteWebDriver with SauceLabs remote Hub URL and access credentials
  • Setting browser, OS version, and screen resolution via MutableCapabilities / sauce:options
  • Viewing live test execution and video recordings in the SauceLabs web dashboard
MODULE 12  Docker for Selenium — Containerized Test Environments
Why this matters: Docker eliminates the "it works on my machine" problem for good. Running Selenium inside Docker containers is now standard practice at companies that run tests in CI pipelines — and it's a skill most testers don't have.
Topics Covered
  • Docker core concepts — images, containers, ports, volumes; docker pull, docker run, docker ps
  • Pulling Selenium's official images: selenium/standalone-chrome, selenium/standalone-firefox
  • Connecting RemoteWebDriver to a containerized browser on http://localhost:4444
  • Watching tests visually inside containers using VNC Viewer (port 5900)
  • Running Selenium Hub + Node in separate containers and linking them via Docker network
  • Running parallel browser containers for cross-browser execution without local installs
  • docker stop / docker rm — cleaning up environments after test runs
MODULE 13  Jenkins CI/CD — Automated Test Pipelines
Why this matters: CI/CD integration is the difference between a framework that runs when someone remembers to trigger it, and one that runs automatically on every code change. Jenkins is still the most widely used CI tool in Java test projects.
Topics Covered
  • Installing Jenkins locally and configuring the Maven plugin and JDK settings
  • Creating a Freestyle job — pointing to a Git repo and triggering mvn test
  • Parameterized builds — adding String Parameter and Choice Parameter for browser, env, suite
  • Passing Jenkins build parameters into Maven via -D${browser} in the goals field
  • HTML Publisher plugin — publishing ExtentReports HTML inside Jenkins after each run
  • Post-build email notifications — configuring SMTP and dynamic report-link emails
  • Build triggers — manual, schedule (cron), and upstream job chaining
MODULE 14  Keyword Driven Framework
Why this matters: A Keyword Driven Framework separates test logic from test data — so QA analysts without coding skills can write test cases in Excel and the framework executes them automatically. This is a sign of a senior framework developer.
Architecture & Concepts
  • What keyword-driven testing is — separating action keywords from test data in an Excel file
  • Excel test case structure — columns for Keyword, Locator Type, Locator Value, Test Data
  • Building a KeywordExecutor / ActionEngine using reflection or a switch statement
Implementation
  • Reading test steps from Excel row by row using XSSFWorkbook / XSSFRow
  • Implementing WebUtil helper methods: clickElement(), typeText(), verifyText(), navigateTo()
  • Dispatching the correct method based on the keyword value read from Excel
  • Adding new test cases entirely in Excel — zero Java code changes required
  • Logging each keyword action to ExtentReports for full traceability
MODULE 15  Live Industry Project — POS Application + Jira + Interview Prep
Why this matters: A working project on a real application is the difference between a resume and a portfolio. You leave this module with something you can demo, explain end-to-end, and be proud of in any senior QA interview.
Live Project
  • Automating a real Point-of-Sale (POS) web application — login, products, orders, billing
  • Applying all course components: TestNG, POM with @FindBy, ExtentReports, Log4J, Excel data, Jenkins CI/CD
  • Jira — creating test cases, logging bugs with screenshots, tracking sprint progress
  • Debugging real failures — identifying whether the issue is in the app, framework, or locator
  • Code review — refactoring for readability, removing duplication, improving structure
Interview Preparation
Design Patterns

Explain Singleton, Factory, Decorator with real code examples from your own project

Framework Walkthrough

Walk through your package structure, layer responsibilities, and why each design decision was made

CI/CD Pipeline

Describe the full chain: Jenkins → pom.xml → testng.xml → @Parameters → test method

Parallel Execution

Explain ThreadLocal<WebDriver> and how you prevented driver conflicts across parallel threads

Data Strategies

Compare Excel, JSON, Properties, MySQL — and justify where you used each in the project

Docker & Grid

Describe how you used Docker containers as browser nodes and ran tests without installing browsers locally