About the course
Playwright is a modern, open-source automation framework that provides a fast, reliable, and capable solution for end-to-end testing of web applications across all major rendering engines (Chromium, Firefox, and WebKit) and platforms (Windows, Linux, macOS). Its key features, such as auto-waiting, test isolation with browser contexts, and powerful tooling, make it an excellent choice for creating stable and robust automated web tests. This 2-day intensive hands-on training course provides a comprehensive introduction to Playwright, focusing on building automated tests using the expressive power of TypeScript, equipping participants with the skills to create, run, manage, debug, and integrate reliable web tests into their software development and delivery pipelines.
The course begins by introducing Playwright's architecture, its importance for modern web testing, and guides participants through the essential steps of setting up a new Playwright project with JavaScript and/or TypeScript. You will learn the basics of writing and running your very first Playwright tests, understanding their fundamental structure and core components, including common Playwright functions and assertions using clear JavaScript / TypeScript syntax. A significant portion of the first day covers leveraging Playwright's powerful Codegen tool to accelerate test creation by automatically generating test scripts based on user interactions recorded in the browser, providing guidance on how to effectively modify and customise this generated code and best practices for incorporating it into your test suite.
Building on foundational test creation, the second day delves into advanced test management techniques, including implementing hooks (beforeEach, afterEach) to efficiently manage test preconditions and cleanup, and writing flexible and reusable tests using parameterization techniques, including utilising external data sources to drive tests. Participants will gain practical skills in running Playwright tests efficiently in different browsers (both headed and headless modes), debugging tests effectively using integrated development environment tools like VSCode, and troubleshooting common issues encountered during test development. The training also covers configuring Playwright to generate informative test reports (such as the HTML report) to interpret test results and, crucially, integrating automated Playwright tests into CI/CD pipelines using examples like GitHub Actions or Jenkins, including handling environment-specific configurations and secrets securely. Through extensive hands-on exercises integrated throughout the two days, attendees will gain practical experience applying Playwright concepts in realistic web testing scenarios, leaving the course ready to implement Playwright in their own projects.
Instructor-led online and in-house face-to-face options are available - as part of a wider customised training programme, or as a standalone workshop, on-site at your offices or at one of many flexible meeting spaces in the UK and around the World.
-
- Understand the purpose, key features, and architecture of Playwright for reliable web test automation.
- Set up a new project with Playwright and JavaScript / TypeScript and configure the development environment (e.g., VSCode).
- Write and run basic Playwright tests using JavaScript / TypeScript syntax, understanding their fundamental structure and components.
- Utilise the Playwright Codegen tool to generate test scripts from user interactions and effectively modify and customise the generated code.
- Implement advanced test management techniques such as hooks (beforeEach, afterEach) and parameterization with external data sources.
- Run Playwright tests in various browsers and configurations (headed/headless) and debug tests effectively using VSCode.
- Configure Playwright to generate and interpret test reports to understand test results.
- Integrate Playwright tests into CI/CD pipelines using examples like GitHub Actions or Jenkins, handling environment configurations and secrets.
- Identify and troubleshoot common issues encountered during Playwright test development.
-
This 2-day intensive hands-on training course is designed for QA Engineers, Test Automation Engineers, Software Developers, and anyone involved in the testing or quality assurance of web applications who wants to learn how to build reliable and efficient automated tests using Playwright and TypeScript. It is ideal for:
QA professionals looking to expand their test automation skills beyond existing tools.
Developers who want to write robust end-to-end tests for their web applications.
Automation Engineers seeking to add Playwright to their automation toolset.
Teams adopting or considering Playwright as their primary web testing framework.
-
Participants should would benefit from having attended our Modern JavaScript training course and/or our TypeScript training course or have some equivalent skills:
Familiarity with web development concepts (HTML, CSS).
Basic understanding of JavaScript or TypeScript syntax (helpful but not strictly required)
Experience using a command-line interface (CLI).
Familiarity with the concept of software testing or test automation is beneficial but not strictly required, as the course starts with fundamentals.
We can customise the training to match your team's experience and needs - with more time and coverage of fundamentals for new starters, for instance.
-
This Playwright course is available for private / custom delivery for your team - as an in-house face-to-face workshop at your location of choice, or as online instructor-led training via MS Teams (or your own preferred platform).
Get in touch to find out how we can deliver tailored training which focuses on your project requirements and learning goals.
-
Introduction and Setup
Course objectives and structure.
Overview of Playwright: Architecture, key features, and its importance for modern web testing.
Introduction to TypeScript: Basic syntax relevant to Playwright.
Setting up a new Playwright and TypeScript project.
Configuring the development environment (e.g., VSCode setup recommendations).
Running initial Playwright setup commands.
Hands-On Exercise: Set up Playwright and TypeScript in a new project, run initial setup commands to verify setup.
Basics of Writing and Running Tests
Introduction to TypeScript syntax used for Playwright tests.
Creating and running a basic "Hello World" style Playwright test.
Understanding the structure and components of a Playwright test file.
Common Playwright functions (e.g., page.goto(), page.click(), page.fill()) and assertions (expect()).
Introduction to Playwright's Codegen tool.
Recording user actions in the browser to generate test scripts automatically.
Modifying and customizing generated code for readability and maintainability.
Best practices for using codegen effectively.
Hands-On Exercise: Write a basic test to interact with a web page, use codegen to create a test script for a simple workflow, and modify the generated code.
Advanced Test Management
Introduction to hooks in Playwright for test lifecycle management.
Using beforeEach to set up test preconditions (e.g., navigating to a page, logging in).
Using afterEach to clean up after tests (e.g., logging out, clearing cookies).
Practical examples and best practices for hook usage.
Writing flexible and reusable tests with parameterization.
Using external data sources (e.g., CSV, JSON) for test parameters.
Implementing parameterized tests in Playwright.
Hands-On Exercise: Implement ‘beforeEach’ and ‘afterEach’ hooks in your test suite, create a parameterized test using an external data source.
Running, Debugging, and Integrating Tests
Running tests in different browsers (Chromium, Firefox, WebKit) and configurations.
Running tests in headless mode vs. headed mode.
Debugging Playwright tests using VSCode debugging tools.
Troubleshooting common issues and errors.
Configuring Playwright to generate test reports.
Understanding different types of reports (e.g., HTML reporter, JSON, JUnit).
Interpreting and using test report data to analyse results.
Overview of CI/CD concepts and the role of automated tests.
Setting up a CI/CD pipeline with popular tools (e.g., GitHub Actions, Jenkins - focusing on the Playwright steps).
Running Playwright tests in CI/CD environments.
Handling environment-specific configurations and secrets in CI/CD.
Wrap-Up and Q&A.
Additional resources for continued learning.
Hands-On Exercise: Run tests across multiple browsers, run in headless mode, use the VSCode debugger, generate and interpret the HTML test report.
-
Playwright Documentation: The official and comprehensive documentation for Playwright, including API references and guides.
Playwright GitHub Repository: The source code for Playwright, useful for exploring issues and contributing.
TypeScript Documentation: Official documentation for the TypeScript language.
VSCode Documentation: Documentation for the Visual Studio Code editor and its debugging capabilities.
GitHub Actions Documentation: Documentation for GitHub's integrated CI/CD service.
Jenkins Documentation: Documentation for the Jenkins automation server.
Trusted by
