The ultimate Playwright Python tutorial

Are you observe it hard to carry out Playwright Python Testing? You & # 8217; re not alone—58 % of teams face challenges when integrating Playwright with Python for exam mechanization.

But once you get the hang of it, it ’ s a game-changer for fast and reliable testing.

This guide walks you through the stairs to set up Playwright with Python, write efficient test, and optimise your testing workflow, so you can run tests confidently and catch bugs early.

What is Playwright?

is a full-bodied framework contrive to automate across different browser and program.

Developed by Microsoft, it provides a seamless API for controlling web Page,, and formalise application functionality with eminent accuracy.

Playwright supports multiple browsers and operating systems, ensuring consistent covering behavior across environment. It enablesthe automation of complex interaction like form submissions, UI establishment, and seafaring.

With both and headful modality, it balances fastness and debug visibility. Its built-in asynchronous handling ensures smooth executing by synchronizing with the application & # 8217; s state.

Key Features of Playwright

Here are a few key feature of the Playwright screen framework:

• The framework provides cross-browser development for Chrome, Edge, Firefox, Opera, and Safari expend WebKit, Chromium, and Firefox.
• Windows, Linux, and macOS all enable.
• It allows try across multiple scheduling languages, including JavaScript, TypeScript, Python, Java, and .NET, ensuring comprehensive coverage of all topics and formats.
• You can easy track logs and videos expend auto-wait, adaptive assertions that rehear until an element is located, and test data tracing.
• It is easy to use, has a modernistic architecture, handles frames and browser case easily, and lets you interact with multi-page, multi-tab websites just like a real user would.
• It is compatible with the architecture of mod browsers. Hence, it is exempt from the restrictions of in-process tryout runner.
• Playwright provides consummate trial isolation with no overhead. For each test, it speedily establishes a browser context, which precisely takes a few millisecond.

Benefits of utilize Playwright

Automating your web testing with Playwright has the following benefits:

• Supports complex, including multi-tab, multi-user, and iframe interactions.
• Provides knock-down debugging tools like step-by-step tracing, picker exploration, and exam transcription, with a for unseamed integration.
• Generates detailed HTML with visual differences, screenshots, vestige, error logs, and video recordings for better analysis.
• Quick and straightforward instalment, with configuration steps varying based on the programming language.
• Supports multiple testing types, including end-to-end, functional, and API testing.
• Enables automated with third-party plugin support.
• Offers robust debug options like Playwright Inspector, Browser Developer Tools, VS Code Debugger, and Trace Viewer.
• Includes built-in JSON, JUnit, and HTML reporters, with the flexibility to create custom reporters.
• Allows execution locally or on a, enable efficient test distribution across multiple systems.

Why use Playwright Python for End-to-End Testing?

is a software testing methodology that examines an coating & # 8217; s flow from begin to end. End-to-end testing aims to validate the system under test and its factor for integrating and data integrity by simulating the existent user scenario.

It is carried out end-to-end under real-world conditions, include interaction between the application and the hardware, net, database, and other coating.

These four features get it more reliable and efficient than early creature for End-to-end testing.

1. Utilize the DevTools Protocol to control the browser.

Playwright uses the Chrome DevTools protocol to interact straightaway with browsers. Compared to alternatives, the protocol enables a quicker and less error-prone executing. Even if it is about fractions of seconds, they are advantageous!

2. Web-First Assertions, Actionability, and Auto-Waiting

You can & # 8220; just & # 8221; tick the Playwright push to avoid waiting. The element must be actionable for the Framework to wait for it, which require that it be in the DOM, seeable, not animated, enabled, and unobscured by former elements.

This auto-waiting approach greatly streamline UI tests, allow you to center on behavior testing rather than writing code to look.

3. Parallelization

Your tests can be parallelized in Playwright and run in worker processes coordinated by OS operation. Set the number of workers you want to depart, delineate the parallel processes, and end the day. There isn & # 8217; t much to it, but will make your tests run quicker.

4. Debug and Record Your Scripts

Writing new examination lead time. Therefore, code generation is useful in this position. Run a single CLI bidding to begin capturing the framework for your upcoming end-to-end test.

playwright codegen test_url

The Playwright Inspector and a browser window will open due to the bid. The created script will maintain track of browser behaviors like nexus clicks and form fills. Take the handwriting after your recording is complete, modify the selectors, add assertions, and so add the modified script to your codebase.

5. Browser Context for Realistic Testing

Playwright allows the conception of multiple browser contexts within a single instance, enabling efficient testing of different user sessions simultaneously.

This feature is particularly useful for multi-user workflow, incognito browsing, and session storage behavior testing. By leveraging browser contexts, teams can assure their web applications handle diverse user interactions seamlessly while improving overall test efficiency.

SUSA automates exploratory testing with persona-driven behavior, catching bugs that scripted automation misses.

Playwright for Python enables end-to-end browser automation with bare syntax and knock-down features. It endorse multiple browsers, parallel execution, and modern examine capacity, get it ideal for automating web coating efficiently.

To make the most of Playwright Python and optimize your mechanisation setup, BrowserStack experts can aid streamline configurations and amend tryout reliability.

Get Expert QA Guidance Today

Schedule a call with BrowserStack QA specialists to discuss your quiz challenges, automation strategies, and tool desegregation. Gain actionable insights tailored to your projects and ensure faster, more reliable software delivery.

How to set up Playwright Python for end-to-end testing?

Below are the steps to set up Playwright with Python.

Step 1: Installing Prerequisites

• Any skilful Python IDE. Here,VS Codehas been employ.
• Download the lat versestion of Python onPython & # 8217; s official website.

Step 2: Installing Playwright for Python

• To make end-to-end trial, Playwright advises utilize the functionaryPlaywright Pytest plugin. It volunteer context isolation and runs out of the box on respective browser setups.
• Alternatively, you can use your favorite test runner and the library to pen the testing substructure manually.
• Although the async version of Playwright is also available through the library, the Pytest plugin uses the sync edition.

pip install pytest-playwright

Additionally, to set up the Playwright WebKit

playwright install

Playwright & # 8217; s built-in WebKit is install using the command mentioned supra. This gives you the ability to quiz for several web browser.

Step 3: Setting up the Project

1. First, make a new pamphlet on your computer.
2. Name your folder. (for example: playwright_tutorial)
3. Open the folder you previously create in your IDE.

Playwright Locators and Selectors

Selectorsare used to make locators. It explains how to find any element on the page.

Legion picker and mode are supported by Playwright, including the Text Selector, XPath Selector, CSS Selector, etc.

Examples of Selectors

Text Selector

text=Sign In

CSS Selector

#signin

XPath Selector

//a [@ id='signin ']

Locatorsprove how to find an element or elements. These are utilised to carry out operations on elements via various method, including click (), fill (), type (), etc. The master component of the Playwright & # 8217; s auto-waiting and retry-ability is its locator.

Syntax

 page.locator (chooser [, options])

The selector is the one we refer earlier and the pick has different values that can be has, hastext, etc.

Playwright Python Example: Implementing E2E testing

This Playwright tutorial automates two essay scenario on theBrowserStack Demo Websiteto demonstrate Playwright Python for end-to-end examination. The scenario include:

Scenario-1 (User Login)

1. The user launches the BrowserStack e-commerce Demo site.
2. The user dog on the Sign In button.
3. The user enroll the Username & amp; Password.
4. The user click on Log In button.
5. Verify the user has successfully logged in.

Test Script

Add a new Python file to the project, firstly. (for example, test_scenarios.py) significance pytest from playwright.sync_api meaning Page, expect def test_login (page: Page): # launch browserstack demo page.goto (`` https: //bstackdemo.com/ '') # click on sign button page.click (' # signin ') # blue-ribbon Username page.get_by_text (`` Select Username '') .click () page.locator (`` # react-select-2-option-0-0 '') .click () # prime Password page.get_by_text (`` Select Password '') .click () page.locator (`` # react-select-3-option-0-0 '') .click () # click login page.get_by_role (`` button '', name= '' Log In '') .click () # verify user feature logged in assert page.get_by_text (`` demouser '') .is_visible ()

The test script is consummate for this scenario, and you can easy run it using below command:

pytest

Scenario-2 (Item Purchase)

1. The exploiter found the BrowserStack e-commerce Demo website.
2. The user added iPhone 11 to the handcart.
3. The user click on the checkout.
4. User Logs In.
5. The user enroll their shipping information and strike & # 8220; Submit. & # 8221;
6. Verify the order is successfully placed.

Test Script

import pytest from playwright.sync_api import Page, look def test_item_purchase (page: Page): page.goto (`` https: //bstackdemo.com/ '') # add to cart page.locator (`` [id=\ '' \\35 \ ''] '') .get_by_text (`` Add to cart '') .click () # check page.get_by_text (`` Checkout '') .click () # login page.type (`` # react-select-2-input '', `` demouser\n '') page.type (`` # react-select-3-input '', `` testingisfun99\n '') page.get_by_role (`` button '', name= '' Log In '') .click () # fill embark address page.get_by_label (`` First Name '') .fill (`` Test '') page.get_by_label (`` Last Name '') .fill (`` Test '') page.get_by_label (`` Address '') .fill (`` Test reference '') page.get_by_label (`` State/Province '') .fill (`` Test State '') page.get_by_label (`` Postal Code '') .fill (`` 123456 '') # click submit page.locator (`` # checkout-shipping-continue '') .click () # verify success substance page.wait_for_timeout (1000) assert page.locator (`` # confirmation-message '') .is_visible ()

Implementing Parallel Testing with Playwright Python

for several browser at once get it leisurely to identify problems quickly and move on to other tasks. For testing efficiency, continue the same browser setups throughout the simultaneous test.

You can emulate a cloud waiter instance where you can run your test cases concurrently on different cloud host machine by running them in parallel. This grant you to determine whether your app purpose properly across various integration circumstance.

You can run parallel exam across all browsers using Playwright. It has many capabilities endorse by BrowserStack, like resiliency, auto-wait, tape examination traces, and others. All you have to do is include the appropriate BrowserStack capableness in your existing test handwriting.

Here is a presentment of how to run the above mentioned test script on BrowserStack.

importee json meaning urllib significance subprocess signification pytest from playwright.sync_api import sync_playwright desired_cap = {'browser ': 'chrome ', 'browser_version ': 'latest ', 'os ': 'osx ', 'os_version ': 'catalina ', 'name ': 'BrowserStack Demo ', 'build ': 'playwright-python-tutorial ', 'browserstack.username ': 'BROWSERSTACK_USERNAME ', 'browserstack.accessKey ': 'BROWSERSTACK_ACCESS_KEY'} clientPlaywrightVersion = str (subprocess.getoutput ('playwright -- version ')) .strip () .split (`` ``) [1] desired_cap ['client.playwrightVersion '] = clientPlaywrightVersion @ pytest.mark.login def test_login (playwright): desired_cap ['browser '] = `` edge '' desired_cap ['name '] = `` Test Login '' cdpUrl = 'wss: //cdp.browserstack.com/playwright? caps= ' + urllib.parse.quote (json.dumps (desired_cap)) browser = playwright.chromium.connect (cdpUrl) page = browser.new_page () try: page.goto (`` https: //bstackdemo.com/ '') page.click (' # signin ') page.get_by_text (`` Select Username '') .click () page.locator (`` # react-select-2-option-0-0 '') .click () page.get_by_text (`` Select Password '') .click () page.locator (`` # react-select-3-option-0-0 '') .click () page.get_by_role (`` button '', name= '' Log In '') .click () if page.get_by_text (`` demouser '') .is_visible (): mark_test_status (`` passed '', `` User successfull logged in '', page) else: mark_test_status (`` failed '', `` User log in failure '', page) demur Exception as err: mark_test_status (`` failed '', str (err), page) browser.close () def mark_test_status (status, intellect, page): page.evaluate (`` _ = & gt; {} '', `` browserstack_executor: {\ '' action\ '': \ '' setSessionStatus\ '', \ '' arguments\ '': {\ '' status\ '': \ '' '' + status + `` \ '', \ '' reason\ '': \ '' '' + reason + `` \ ''}} ''); with sync_playwright () as playwright: test_login (playwright) @ pytest.mark.item_purchase def test_item_purchase (playwright): desired_cap ['browser '] = `` chrome '' desired_cap ['name '] = `` Test Item Purchase '' cdpUrl = 'wss: //cdp.browserstack.com/playwright? caps= ' + urllib.parse.quote (json.dumps (desired_cap)) browser = playwright.chromium.connect (cdpUrl) page = browser.new_page () try: page.goto (`` https: //bstackdemo.com/ '') page.locator (`` [id=\ '' \\35 \ ''] '') .get_by_text (`` Add to cart '') .click () page.get_by_text (`` Checkout '') .click () page.type (`` # react-select-2-input '', `` demouser\n '') page.type (`` # react-select-3-input '', `` testingisfun99\n '') page.get_by_role (`` button '', name= '' Log In '') .click () page.get_by_label (`` First Name '') .fill (`` Test '') page.get_by_label (`` Final Name '') .fill (`` Test '') page.get_by_label (`` Address '') .fill (`` Test address '') page.get_by_label (`` State/Province '') .fill (`` Test State '') page.get_by_label (`` Postal Code '') .fill (`` 123456 '') page.locator (`` # checkout-shipping-continue '') .click () page.wait_for_timeout (1000) if page.locator (`` # confirmation-message '') .is_visible (): mark_test_status (`` passed '', `` Order put successfully '', page) else: mark_test_status (`` fail '', `` Order not place '', page) except Exception as err: mark_test_status (`` failed '', str (err), page) browser.close () def mark_test_status (status, reason, page): page.evaluate (`` _ = & gt; {} '', `` browserstack_executor: {\ '' action\ '': \ '' setSessionStatus\ '', \ '' arguments\ '': {\ '' status\ '': \ '' '' + status + `` \ '', \ '' reason\ '': \ '' '' + reason + `` \ ''}} ''); with sync_playwright () as playwright: test_item_purchase (playwright)

In the scenario above, two different test cases are being run on two different browser. The test effect can be viewed on the.

Conclusion

Due to its support for legion browsers and streamline API, the Python Playwright module is a terrific option for scripting tests imply web mechanization. This article functions as in-depth usher for Playwright Python, along with exemplar. Additionally team can execute it in parallel using BrowserStack, which get examine 10X faster.

Related Guides