Automation with Python & Selenium

You can identify testable automation candidates and map out an end-to-end regression strategy for web applications.

1. The software testing lifecycle90 min
   • STLC phases
   • defect life cycle
   • test planning
   • test sign-off criteria
2. Manual versus automated testing90 min
   • ROI of automation
   • exploratory testing vs scripts
   • regression overhead
   • test flakiness cost
3. When and what to automate90 min
   • automation pyramid
   • repetitive workflows
   • data-heavy validations
   • smoke and sanity suites
4. Automation frameworks overview90 min
   • modular frameworks
   • keyword-driven approach
   • data-driven architecture
   • hybrid framework design
5. The automation tester's toolkit90 min
   • IDE configuration
   • version control with git
   • package management
   • terminal commands

Hands-on project: Write an automation feasibility report for a live e-commerce checkout flow, categorizing test cases by automation priority and risk.

You can write clean, modular Python scripts utilizing functions, classes, and file handlers tailored for test automation.

1. Variables, data types and control flow120 min
   • dynamic typing
   • if-elif-else blocks
   • for and while loops
   • type conversion
2. Lists, dictionaries, tuples and sets180 min
   • list comprehensions
   • dictionary key-value lookups
   • tuple unpacking
   • set operations
3. Functions and modules120 min
   • def keyword
   • args and kwargs
   • import statements
   • scope and namespaces
4. Object-oriented programming with classes180 min
   • class constructors (__init__)
   • self keyword
   • inheritance
   • encapsulation
5. Exceptions and file handling120 min
   • try-except-finally blocks
   • raising custom exceptions
   • open() context managers
   • pathlib module

Hands-on project: Build a CLI utility script that parses CSV log files, handles malformed rows with custom exceptions, and outputs a summary JSON report.

You can bootstrap Selenium WebDriver instances, manage browser drivers, and control navigation programmatically.

1. Selenium architecture and components90 min
   • WebDriver protocol
   • JSON Wire Protocol vs W3C
   • driver binaries
   • browser client bindings
2. WebDriver and browser drivers90 min
   • webdriver-manager package
   • driver instantiation
   • browser capabilities
   • headless execution
3. Launching and controlling browsers90 min
   • maximize_window()
   • set_window_size()
   • refresh() and back() commands
   • close() vs quit()
4. Your first automation script90 min
   • end-to-end script skeleton
   • driver.get() method
   • basic assertions
   • clean teardown hooks
5. Browser navigation and commands90 min
   • history navigation
   • current_url property
   • page_source retrieval
   • title validation

Hands-on project: Write a Python script that initializes Chrome headless mode, navigates to target test environments, and asserts page titles and URLs.

You can locate complex web elements using robust XPath and CSS selectors while handling dynamic load waits.

1. Locators: id, name, XPath and CSS180 min
   • By.ID and By.NAME
   • absolute vs relative XPath
   • CSS selector syntax
   • XPath functions (contains, text)
2. Finding single and multiple elements120 min
   • find_element() method
   • find_elements() collection handling
   • NoSuchElementException handling
   • stale element reference exceptions
3. Clicks, typing and form controls120 min
   • element.click()
   • send_keys() input handling
   • clear() method
   • attribute extraction
4. Dropdowns, checkboxes and radio buttons120 min
   • Select class in Selenium
   • select_by_visible_text()
   • is_selected() validation
   • multi-select options
5. Implicit, explicit and fluent waits180 min
   • WebDriverWait class
   • expected_conditions module
   • element_to_be_clickable
   • polling frequency configuration

Hands-on project: Implement an interactive test script that fills a multi-step registration form using explicit waits and custom XPath axes.

You can manipulate browser windows, handle alerts, execute raw JavaScript, and automate file transfers.

1. Alerts, frames and windows90 min
   • switch_to.alert
   • switch_to.frame()
   • switch_to.window()
   • window handles iteration
2. ActionChains: mouse and keyboard90 min
   • context_click()
   • drag_and_drop()
   • move_to_element()
   • key_down() modifier keys
3. JavaScript executor90 min
   • execute_script() method
   • scrolling to element
   • highlighting elements
   • handling hidden inputs
4. Screenshots and capturing failures90 min
   • save_screenshot()
   • get_screenshot_as_png()
   • attaching images to logs
   • timestamping artifact files
5. File upload and download90 min
   • sending file paths to input
   • Chrome preferences for download directory
   • verifying downloaded files
   • cleanup procedures

Hands-on project: Build a test routine handling nested iframes, modal alert pop-ups, and native file uploads using ActionChains.

You can structure automated test suites using PyTest fixtures, markers, parameterization, and parallel runners.

1. PyTest basics and structure90 min
   • test naming conventions
   • pytest discovery rules
   • assert statements
   • running tests via CLI
2. Fixtures and configuration90 min
   • @pytest.fixture decorator
   • conftest.py scope
   • yield fixtures for teardown
   • autouse fixtures
3. Assertions and markers90 min
   • @pytest.mark decorators
   • custom markers registration
   • skipping and xfailing tests
   • inspecting traceback output
4. Parameterization90 min
   • @pytest.mark.parametrize
   • passing multiple data tuples
   • indirect parameterization
   • dynamic test generation
5. Parallel execution and reports90 min
   • pytest-xdist plugin
   • worker distribution (-n auto)
   • HTML test reports
   • XML output generation

Hands-on project: Create a parameterized PyTest suite with setup/teardown fixtures and custom markers for smoke and regression groups.

You can design maintainable enterprise test frameworks following the Page Object Model architectural pattern.

1. Why frameworks matter120 min
   • code duplication issues
   • maintenance bottlenecks
   • separation of concerns
   • scalability principles
2. The Page Object Model in Python180 min
   • class per web page
   • encapsulating locators
   • exposing action methods
   • fluent page chaining
3. Reusable utilities and base classes120 min
   • BasePage superclass
   • common wait wrappers
   • logger configuration
   • browser initialization helpers
4. Building a maintainable framework180 min
   • directory tree structure
   • configuration management
   • handling environment URLs
   • global test constants
5. Project structure with pip and venv120 min
   • python -m venv setup
   • requirements.txt dependency locking
   • editable installs
   • virtual environment activation

Hands-on project: Refactor raw test scripts into a modular Page Object Model architecture with dedicated base page classes and clean project layouts.

You can decouple test data from test logic by reading credentials and parameters from external Excel, CSV, and config files.

1. Externalizing test data90 min
   • data-driven testing rationale
   • hardcoded data anti-patterns
   • test data formats
   • managing test states
2. Reading from Excel and CSV90 min
   • openpyxl workbook reading
   • cell iteration and parsing
   • csv module reader usage
   • mapping rows to dictionaries
3. Configuration files90 min
   • configparser module
   • ini file structure
   • reading environment settings
   • overriding via CLI flags
4. Parameterized tests in practice90 min
   • feeding dataset lists into pytest
   • dynamic test naming
   • handling missing dataset cells
   • reporting dataset failures
5. Data-driven suites90 min
   • scaling test matrices
   • negative test data generation
   • cleanup after data runs
   • test isolation guarantees

Hands-on project: Implement an openpyxl data provider that feeds multi-row user test data into a login and checkout test suite.

You can author business-readable test scenarios using Gherkin syntax and implement Python step definitions with Behave.

1. Behaviour-driven development concepts90 min
   • BDD philosophy
   • collaboration between roles
   • Specification by Example
   • living documentation
2. Gherkin and feature files90 min
   • Given-When-Then syntax
   • Scenario Outlines and Examples
   • Background blocks
   • feature file organization
3. Step definitions90 min
   • @given, @when, @then decorators
   • matching regex parameters
   • context object sharing
   • table data parsing
4. Behave with Selenium90 min
   • environment.py hooks
   • browser lifecycle management in BDD
   • integrating page objects into steps
   • handling test failures in hooks
5. BDD reports90 min
   • behave formatter options
   • JSON report output
   • allure-behave integration
   • step execution timing

Hands-on project: Create feature files for an online cart workflow and link them to Selenium test execution using Behave step definitions.

You can orchestrate cross-browser parallel test runs on Selenium Grid and automate execution via Jenkins pipelines.

1. Selenium Grid architecture90 min
   • Hub and Node model
   • Standalone mode
   • Docker-based Grid setup
   • session routing
2. Cross-browser and parallel testing90 min
   • RemoteWebDriver configuration
   • browser capabilities mapping
   • parallel execution on Grid
   • resolving node bottlenecks
3. Integrating with Jenkins90 min
   • Jenkinsfile declarative syntax
   • pipeline agent configuration
   • python virtualenv setup in CI
   • storing test credentials securely
4. Running tests in CI/CD90 min
   • triggered builds on git push
   • handling headless CI constraints
   • archiving test artifacts
   • build failure thresholds
5. Allure and rich reporting90 min
   • allure-pytest adapter
   • generating trend histories
   • attaching logs and screenshots
   • Jenkins Allure plugin setup

Hands-on project: Configure a Jenkinsfile pipeline stage that executes a PyTest suite across remote browser nodes and publishes Allure reports.

You can test through the fastest layer that proves the behaviour instead of driving the browser for everything.

1. Choosing the right layer to test at90 min
   • UI vs API vs unit cost
   • What only UI can prove
   • Test pyramid in practice
2. API testing with requests and pytest90 min
   • Session and auth headers
   • Status and payload assertions
   • Parametrised cases
3. Schema and contract validation90 min
   • JSON schema assertions
   • Response shape drift
   • Backward compatibility
4. Verifying state in the database90 min
   • Direct query assertions
   • Fixture setup and teardown
   • Isolation between tests

Hands-on project: Replace six slow UI tests with requests-based API tests covering the same assertions, add schema validation on the responses, verify the resulting database state directly, and report the runtime saved.

You can make a suite that fails only when the product is broken, and run it in minutes.

1. Why tests flake90 min
   • Implicit vs explicit waits
   • Race on async rendering
   • Shared test data
2. Waiting on conditions, never on time90 min
   • WebDriverWait
   • expected_conditions
   • Custom wait predicates
3. Parallel execution without collisions90 min
   • pytest-xdist workers
   • Per-worker test data
   • Thread-safe drivers
4. Reporting that gets acted on90 min
   • Allure or HTML reports
   • Screenshot and log on failure
   • Tracking pass-rate trend

Hands-on project: Take a suite with intermittent failures, replace every sleep with an explicit condition, parallelise it with pytest-xdist and fix the resulting shared-state collisions, then publish an Allure report with screenshots on failure and show the pass rate before and after.

You can build, deploy, and present a complete enterprise-grade test automation framework integrating POM, PyTest, BDD, and CI/CD.

1. Design a complete framework90 min
   • architecture blueprinting
   • module integration plan
   • configuration centralization
   • coding standard reviews
2. Combine POM, PyTest, data-driven and BDD90 min
   • unified test suite assembly
   • bridging pytest and behave
   • shared driver fixtures
   • data pipeline wiring
3. Run cross-browser in Selenium Grid90 min
   • remote execution validation
   • parallel node load testing
   • network latency troubleshooting
   • flaky test mitigation
4. Integrate with a CI pipeline90 min
   • end-to-end pipeline verification
   • automated report publishing
   • failure notification setup
   • pipeline optimization
5. Portfolio, resume, mock interviews and career prep90 min
   • GitHub repository polishing
   • resume bullet point drafting
   • SDET interview question walkthrough
   • mock technical interview simulation

Hands-on project: Deliver a production-ready automation framework repository featuring POM, data-driven tests, Behave BDD, and a fully passing Jenkins CI pipeline.