Automation Testing

The Automation Testing course at RexGalaxy Academy is designed for students, freshers, manual testers, QA engineers, and working professionals who want to build strong automation skills for modern software testing roles. The course begins with testing fundamentals and automation mindset, then moves step by step into programming basics, Selenium WebDriver, locators, waits, test execution, framework design, API testing, reporting, Git, CI/CD awareness, cross-browser execution, and capstone portfolio work.

This training is practical and career-focused. Students do not only learn commands; they learn how automation fits into real QA teams, how test cases are converted into scripts, how scripts are organized into frameworks, how reports and logs are generated, and how automation work is presented during interviews. The course also includes repeated practice, project-style assignments, debugging activities, and interview-oriented explanation of every important concept.

Key learning highlights:

• Build a strong foundation in SDLC, STLC, QA roles, test levels, test design, defect flow, and automation scope.

• Learn programming basics required for writing clean, reusable, and maintainable automation scripts.

• Automate browser applications using Selenium WebDriver, stable locators, waits, actions, assertions, screenshots, and reports.

• Design a reusable automation framework using Page Object Model, configuration files, utility classes, test data, logs, and reporting structure.

• Practice API testing basics, Git workflow, CI/CD awareness, cross-browser execution, cloud testing concepts, and capstone project documentation.

By the end of this program, learners can create automation scripts, structure a framework, explain project architecture, troubleshoot failures, generate execution evidence, and present a portfolio-ready automation project with confidence.

This module creates the foundation required before writing automation scripts. Students learn how software testing works in real projects and why automation is introduced only after understanding quality, risk, business flow, and repeatable testing needs.

Topics covered:

• SDLC, STLC, QA role, tester responsibilities, test planning, test design, test execution, defect reporting, and release support.

• Manual testing concepts including functional testing, smoke testing, sanity testing, regression testing, retesting, integration testing, system testing, and acceptance testing.

• Test case writing, test scenarios, expected results, actual results, test data, priority, severity, defect lifecycle, and evidence collection.

• Automation scope, automation feasibility, when to automate, when not to automate, and how to select suitable test cases.

• Automation mindset: stable flows, repeatable checks, maintainability, script reliability, execution speed, and business value.

• Difference between manual testing, automation testing, API testing, performance testing, and SDET-oriented work.

Practical outcome:

• Students can explain testing fundamentals clearly and understand how automation supports real QA work instead of replacing good testing thinking.

This module teaches the programming concepts needed to write automation scripts in a clean and reusable way. The focus is on practical coding for QA automation, not unnecessary theory.

Topics covered:

• Core programming basics such as variables, data types, operators, conditions, loops, arrays or lists, strings, methods, and reusable functions.

• Object-oriented programming concepts including classes, objects, constructors, inheritance awareness, encapsulation, and method reuse.

• Exception handling, debugging, console output, code flow reading, and common coding mistakes made by beginners.

• File handling basics for reading data, writing logs, maintaining configuration, and organizing test resources.

• Writing utility methods for waits, clicks, typing, screenshots, random data, date handling, browser setup, and validation.

• Clean coding practices including naming conventions, folder structure, comments, reusable logic, and avoiding repeated code.

Practical outcome:

• Students can write basic programs confidently and use programming logic to build maintainable automation scripts.

This module introduces Selenium WebDriver as the core browser automation tool. Students learn how Selenium controls browsers, how scripts are structured, and how to automate common UI actions.

Topics covered:

• Selenium overview, WebDriver architecture, browser drivers, browser launch, navigation commands, page title, URL checks, and browser control.

• WebDriver methods for opening websites, clicking elements, typing text, clearing fields, reading text, checking attributes, and closing sessions.

• Browser automation workflow, script structure, setup and teardown, execution flow, and common runtime errors.

• Handling links, buttons, input fields, forms, checkboxes, radio buttons, dropdowns, web tables, alerts, frames, windows, and tabs.

• Browser actions such as mouse hover, double click, right click, drag and drop awareness, keyboard actions, scrolling, and JavaScript executor awareness.

• Debugging Selenium scripts using screenshots, logs, browser state, and step-by-step checks.

Practical outcome:

• Students can create Selenium scripts for common browser flows and understand how WebDriver interacts with web applications.

This module focuses on element identification, one of the most important skills in automation testing. Students learn how to inspect web pages and choose locators that remain stable even when UI structure changes.

Topics covered:

• DOM inspection using browser developer tools and understanding HTML tags, attributes, text, hierarchy, and dynamic values.

• Locator strategies including id, name, class name, link text, partial link text, tag name, CSS selector, and XPath.

• XPath fundamentals including absolute XPath, relative XPath, contains, starts-with, text, indexes, parent-child relationships, siblings, and dynamic XPath handling.

• CSS selector basics including id selector, class selector, attribute selector, contains-like patterns, child selectors, and practical selector writing.

• Handling dynamic elements, repeated elements, hidden elements, stale elements, delayed elements, and changing attributes.

• Locator best practices, avoiding brittle locators, using readable selectors, and creating locator repositories for framework use.

Practical outcome:

• Students can inspect web pages, identify reliable locators, fix locator failures, and improve script stability.

This module explains how automation scripts are organized and executed as proper test cases. Students learn how test runners help manage assertions, setup, teardown, grouping, reports, and controlled execution.

Topics covered:

• Test runner concepts using TestNG or PyTest depending on implementation path, including annotations or fixtures, setup, teardown, test methods, and execution order.

• Assertions, validation logic, hard assertions, soft assertions awareness, readable failure messages, and result interpretation.

• Test grouping, priorities, dependencies awareness, parameterization, suites, test selection, and controlled execution.

• Running tests from IDE, command line, build tools, and test configuration files.

• Understanding pass, fail, skip, error, flaky execution, failed screenshots, logs, and report evidence.

• Writing clean test cases that are independent, repeatable, readable, and suitable for regression execution.

Practical outcome:

• Students can organize automation scripts as real test cases and execute them through a professional test runner structure.

This module teaches students how to move from individual scripts to a reusable automation framework. The focus is on structure, maintainability, configuration, and project-level thinking.

Topics covered:

• Framework architecture, folder structure, base classes, driver management, configuration files, utility classes, page classes, test classes, resources, reports, logs, and screenshots.

• Choosing a framework style such as modular, data-driven, keyword-aware, hybrid awareness, and Page Object Model-centered design.

• Browser setup, environment configuration, URL management, timeout management, reusable WebDriver methods, and centralized common actions.

• Managing test data, application credentials for test environments, reusable constants, and environment-specific settings.

• Error handling, screenshot capture on failure, logs, retry awareness, and clean execution reports.

• Framework documentation so another tester can install, understand, execute, and extend the project.

Practical outcome:

• Students can design a maintainable automation framework instead of writing scattered scripts.

This module goes deeper into Page Object Model, which is widely used in Selenium frameworks. Students learn how to separate page actions from test logic and create reusable utilities for repeated automation tasks.

Topics covered:

• Page Object Model concept, page classes, page methods, element repositories, page actions, and test layer separation.

• Base page design, common actions, click methods, type methods, wait methods, scroll methods, screenshot methods, and validation helpers.

• Creating reusable utilities for browser management, config reading, file handling, test data, screenshots, waits, logs, reports, and assertions.

• Reducing duplicate code, improving readability, and making tests easier to update when UI changes.

• Handling common flows such as login, logout, navigation, menu selection, search, form submission, and validation screens.

• Writing project code that can be explained clearly in interviews and reviewed easily by teams.

Practical outcome:

• Students can build automation projects where test cases are clean and page-level logic is reusable.

This module teaches students how to run the same test logic with different data and how to generate useful evidence after execution. Reporting and test data handling are essential for professional automation work.

Topics covered:

• Data-driven testing concepts, positive and negative data, multiple user roles, multiple environments, and repeatable test sets.

• Reading data from Excel, CSV, JSON, properties files, or framework-supported sources depending on the chosen stack.

• Parameterization, data providers, fixtures, reusable data utilities, and separating data from test logic.

• Reporting concepts including HTML reports, execution summaries, pass/fail status, screenshots, logs, timestamps, and failure reasons.

• Capturing screenshots on failure, attaching evidence, maintaining result folders, and reviewing reports after execution.

• Understanding test result analysis, flaky test identification, failure categorization, and regression execution review.

Practical outcome:

• Students can run automation tests with multiple data sets and generate readable reports with screenshots and execution evidence.

This module introduces API testing and shows how automation testers can validate backend behavior along with UI flows. Students learn basic API concepts and how API checks support stronger automation projects.

Topics covered:

• API fundamentals, client-server communication, REST concepts, endpoints, request methods, headers, parameters, payloads, status codes, and responses.

• Postman awareness, request creation, response validation, collections, environments, and manual API verification.

• API automation basics using a suitable library, request execution, response parsing, assertions, schema awareness, and error handling.

• Connecting API checks with UI automation, such as preparing data, validating backend state, reducing UI dependency, and improving test reliability.

• Authentication awareness, tokens, headers, cookies, environment variables, and safe test data handling.

• Writing API test scripts, validating status codes, response body, response time awareness, and integrating API checks into reports.

Practical outcome:

• Students understand API testing basics and can add simple API validations to an automation testing project.

This module introduces the workflow used by professional teams to manage code and execute automation in pipelines. Students learn the basic DevOps awareness expected from automation testers and SDET-oriented roles.

Topics covered:

• Git fundamentals, repository creation, clone, status, add, commit, push, pull, branch awareness, merge awareness, and GitHub project organization.

• Writing README files, documenting setup steps, execution commands, tools used, framework structure, reports, and screenshots.

• Build tool awareness such as Maven or Gradle for Java, or pip and requirements management for Python depending on course path.

• Command-line execution, dependency management, test suite execution, and report generation from terminal.

• CI/CD basics, Jenkins awareness, GitHub Actions awareness, scheduled runs, triggered runs, build status, artifacts, and test reports.

• Understanding how automation fits into continuous testing, regression pipelines, release checks, and team collaboration.

Practical outcome:

• Students can maintain automation code in Git and understand how tests are executed in CI/CD pipelines.

This module teaches students how automation suites are executed across browsers and environments. Learners understand real-world compatibility testing and how teams scale automation beyond one local browser.

Topics covered:

• Cross-browser testing concepts including Chrome, Edge, Firefox, browser versions, operating systems, screen sizes, and compatibility risks.

• Browser matrix planning, environment compatibility checks, smoke testing, regression selection, and browser-specific issue analysis.

• Parallel execution concepts, test isolation, independent test data, session handling, thread safety awareness, and execution time reduction.

• Selenium Grid awareness, remote execution concepts, local grid versus cloud grid, and environment configuration.

• Cloud testing awareness using cloud browser platforms, execution reports, screenshots, logs, videos, and device/browser combinations.

• Handling flaky tests during parallel and remote execution through better waits, stronger locators, clean setup, and controlled data.

Practical outcome:

• Students can explain cross-browser execution, parallel testing, and cloud execution concepts used in professional automation teams.

The final module brings the complete course together through an end-to-end automation project and interview preparation. Students create portfolio material that demonstrates practical automation ability.

Topics covered:

• Capstone project planning with application selection, module understanding, scenario listing, test case design, automation scope, and execution plan.

• Building end-to-end automated flows such as login, search, form submission, validation, negative scenarios, API-supported checks, screenshots, logs, and reports.

• Completing a framework with Page Object Model, reusable utilities, configuration, test data, report folders, GitHub documentation, and execution commands.

• Preparing README documentation with project overview, tools used, setup steps, folder structure, test execution, reports, screenshots, and known limitations.

• Resume preparation for automation testing skills, Selenium, framework design, API testing, Git, CI/CD awareness, and project explanation.

• Interview preparation covering testing fundamentals, Selenium WebDriver, locators, waits, TestNG or PyTest, POM, reports, API basics, CI/CD, debugging, and real project scenarios.

Practical outcome:

• Students complete the course with a project they can explain confidently in interviews and use as portfolio evidence for automation testing roles.