Playwright with Python, Java & .NET

python3 -m venv .venv
.venv/bin/pip install pytest-playwright==0.10.0 playwright==1.63.0
.venv/bin/playwright install chromium webkit   # download the browsers
.venv/bin/playwright --version
# Version 1.63.0

$ .venv/bin/playwright install --dry-run chromium | head -4
Chrome for Testing 153.0.8010.12 (playwright chromium v1243)
  Install location:    /Users/me/Library/Caches/ms-playwright/chromium-1243
  Download url:        https://cdn.playwright.dev/builds/cft/153.0.8010.12/mac-arm64/chrome-mac-arm64.zip

# pytest.ini
[pytest]
addopts = --base-url=http://localhost:3920 --output=test-results
testpaths = tests

# tests/conftest.py
import pytest
from playwright.sync_api import APIRequestContext, Playwright, expect


@pytest.fixture(scope="session")
def browser_context_args(browser_context_args):
    # Extends the options the plugin builds from the CLI flags (--device, --base-url, ...).
    return {**browser_context_args, "locale": "en-GB"}


@pytest.fixture(autouse=True)
def reset_data(playwright: Playwright, base_url: str):
    # Arrange through the HTTP API instead of the UI, as in the other examples.
    request: APIRequestContext = playwright.request.new_context(base_url=base_url)
    request.post("/api/test/reset")
    request.dispose()


def pytest_configure():
    expect.set_options(timeout=5_000)

# tests/test_bookshelf.py
import os
import re

import pytest
from playwright.sync_api import Page, expect

READER_PASSWORD = os.environ["BOOKSHELF_READER_PASSWORD"]


def test_search_finds_a_book(page: Page):
    page.goto("/books")
    page.get_by_test_id("search-input").fill("quiet")
    page.get_by_role("button", name="Search").click()
    expect(page.get_by_test_id("book-card")).to_have_count(1)
    expect(page.get_by_role("heading", name="The Quiet Compiler")).to_be_visible()


def test_reader_adds_a_review(page: Page):
    page.goto("/signin")
    page.get_by_label("Username").fill("reader")
    page.get_by_label("Password").fill(READER_PASSWORD)
    page.get_by_test_id("signin-submit").click()
    expect(page).to_have_url(re.compile(r"/account$"))

    page.goto("/books/3")
    page.get_by_label("Rating").select_option("4")
    page.get_by_label("Your review").fill("A lovely, detailed field guide.")
    page.get_by_role("button", name="Submit review").click()

    review = page.get_by_test_id("review").filter(has_text="lovely")
    expect(review).to_have_attribute("data-state", "saved")


@pytest.mark.browser_context_args(timezone_id="Europe/Berlin", locale="de-DE")
def test_context_args_marker(page: Page):
    page.goto("/")
    assert page.evaluate("navigator.language") == "de-DE"
    assert page.evaluate("Intl.DateTimeFormat().resolvedOptions().timeZone") == "Europe/Berlin"


def test_two_users_with_new_context(page: Page, new_context):
    other = new_context()
    other_page = other.new_page()
    page.goto("/signin")
    other_page.goto("/signin")
    assert page.context is not other_page.context

$ export BOOKSHELF_READER_PASSWORD=...   # the reader's password; never commit it
$ .venv/bin/pytest -v
collected 4 items

tests/test_bookshelf.py::test_search_finds_a_book[chromium] PASSED       [ 25%]
tests/test_bookshelf.py::test_reader_adds_a_review[chromium] PASSED      [ 50%]
tests/test_bookshelf.py::test_context_args_marker[chromium] PASSED       [ 75%]
tests/test_bookshelf.py::test_two_users_with_new_context[chromium] PASSED [100%]

============================== 4 passed in 1.06s ===============================

$ .venv/bin/pytest --browser chromium --browser webkit --tracing on --video on --screenshot on -v
...
tests/test_bookshelf.py::test_search_finds_a_book[chromium] PASSED       [ 12%]
...
tests/test_bookshelf.py::test_two_users_with_new_context[webkit] PASSED  [100%]

============================== 8 passed in 5.95s ===============================

$ find test-results/tests-test-bookshelf-py-test-reader-adds-a-review-chromium -type f
.../video.webm
.../test-finished-1.png
.../trace-1.zip
.../trace-2.zip

$ .venv/bin/pytest failing --tracing retain-on-failure --screenshot only-on-failure \
    --video retain-on-failure --slowmo 100
...
E       AssertionError: Locator expected to have count '7'
E       Actual value: 6
E       Call log:
E         - Expect "to_have_count" get_by_test_id("book-card") with timeout 1000ms
E         - waiting for get_by_test_id("book-card")
E           11 × locator resolved to 6 elements
E              - unexpected value "6"
...
FAILED failing/test_fail.py::test_wrong_count[chromium]

$ find test-results -type f
test-results/failing-test-fail-py-test-wrong-count-chromium/test-failed-1.png
test-results/failing-test-fail-py-test-wrong-count-chromium/video.webm
test-results/failing-test-fail-py-test-wrong-count-chromium/trace.zip

$ .venv/bin/pip install pytest-xdist
$ .venv/bin/pytest tests -n 2
2 workers [4 items]

....                                                                     [100%]
============================== 4 passed in 1.51s ===============================

# async_tests/pytest.ini
[pytest]
asyncio_default_test_loop_scope = session
asyncio_default_fixture_loop_scope = session
addopts = --base-url=http://localhost:3920 --output=test-results

# async_tests/conftest.py
import pytest_asyncio
from playwright.async_api import Playwright


@pytest_asyncio.fixture(autouse=True, loop_scope="session")
async def reset_data(playwright: Playwright, base_url: str):
    request = await playwright.request.new_context(base_url=base_url)
    await request.post("/api/test/reset")
    await request.dispose()

# async_tests/test_async.py
import os
import re

import pytest
from playwright.async_api import Page, expect


@pytest.mark.asyncio(loop_scope="session")
async def test_reader_adds_a_review(page: Page):
    await page.goto("/signin")
    await page.get_by_label("Username").fill("reader")
    await page.get_by_label("Password").fill(os.environ["BOOKSHELF_READER_PASSWORD"])
    await page.get_by_test_id("signin-submit").click()
    await expect(page).to_have_url(re.compile(r"/account$"))

    await page.goto("/books/3")
    await page.get_by_label("Rating").select_option("4")
    await page.get_by_label("Your review").fill("A lovely, detailed field guide.")
    await page.get_by_role("button", name="Submit review").click()
    await expect(page.get_by_test_id("review").filter(has_text="lovely")).to_have_attribute("data-state", "saved")

$ ../.venv-async/bin/pytest -v
test_async.py::test_reader_adds_a_review[chromium] PASSED                [100%]
============================== 1 passed in 0.64s ===============================

# library_sync.py
from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch()
    context = browser.new_context(base_url="http://localhost:3920")
    page = context.new_page()
    page.goto("/books")
    page.get_by_test_id("search-input").fill("quiet")
    page.get_by_role("button", name="Search").click()
    page.wait_for_selector("[data-testid=book-card]")
    print(page.get_by_test_id("book-card").count(), "book found:", page.get_by_test_id("book-title").first.text_content())
    context.close()
    browser.close()

# library_async.py
import asyncio

from playwright.async_api import async_playwright


async def main():
    async with async_playwright() as p:
        browser = await p.chromium.launch()
        page = await browser.new_page(base_url="http://localhost:3920")
        await page.goto("/books")
        await page.get_by_test_id("search-input").fill("quiet")
        await page.get_by_role("button", name="Search").click()
        await page.get_by_test_id("book-card").first.wait_for()
        print(await page.get_by_test_id("book-card").count(), "book found:", await page.get_by_test_id("book-title").first.text_content())
        await browser.close()


asyncio.run(main())

1 book found: The Quiet Compiler

context.tracing.start(snapshots=True, aria_snapshots=True, screen_snapshots=True, sources=True)
page = context.new_page()
page.goto("/books")
page.get_by_test_id("book-card").first.click()
context.tracing.stop(path="test-results/library-trace.zip")

<project xmlns="http://maven.apache.org/POM/4.0.0">
  <modelVersion>4.0.0</modelVersion>
  <groupId>demo</groupId>
  <artifactId>bookshelf-playwright</artifactId>
  <version>1.0.0</version>
  <properties>
    <maven.compiler.release>17</maven.compiler.release>
    <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
    <playwright.version>1.63.0</playwright.version>
  </properties>
  <dependencies>
    <dependency>
      <groupId>com.microsoft.playwright</groupId>
      <artifactId>playwright</artifactId>
      <version>${playwright.version}</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>org.junit.jupiter</groupId>
      <artifactId>junit-jupiter</artifactId>
      <version>5.14.4</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
  <build>
    <plugins>
      <plugin>
        <artifactId>maven-surefire-plugin</artifactId>
        <version>3.5.4</version>
      </plugin>
    </plugins>
  </build>
</project>

mvn exec:java -e -D exec.mainClass=com.microsoft.playwright.CLI -D exec.args="install"
# test-scoped dependency:
mvn exec:java -e -D exec.mainClass=com.microsoft.playwright.CLI -D exec.classpathScope=test \
  -D exec.args="install --with-deps chromium"
# the same CLI prints what it would do:
mvn -q exec:java -D exec.mainClass=com.microsoft.playwright.CLI -D exec.classpathScope=test \
  -D exec.args="install --dry-run chromium"

// build.gradle
plugins {
  application
  id 'java'
}

repositories {
  mavenCentral()
}

dependencies {
  implementation 'com.microsoft.playwright:playwright:1.63.0'
}

application {
  mainClass = 'org.example.App'
}

// Usage: ./gradlew playwright --args="help"
task playwright(type: JavaExec) {
  classpath sourceSets.test.runtimeClasspath
  mainClass = 'com.microsoft.playwright.CLI'
}

test {
  useJUnitPlatform()
}

package demo;

import static com.microsoft.playwright.assertions.PlaywrightAssertions.assertThat;

import com.microsoft.playwright.*;
import com.microsoft.playwright.options.AriaRole;
import java.util.regex.Pattern;
import org.junit.jupiter.api.*;

class BookshelfPlainTest {
  static final String BASE_URL = System.getenv().getOrDefault("BASE_URL", "http://localhost:3000");
  static final String READER_PASSWORD = System.getenv("BOOKSHELF_READER_PASSWORD");

  // Shared by every test in the class.
  static Playwright playwright;
  static Browser browser;
  // One new instance per test.
  BrowserContext context;
  Page page;

  @BeforeAll
  static void launchBrowser() {
    playwright = Playwright.create();
    browser = playwright.chromium().launch();
    APIRequestContext request = playwright.request().newContext(new APIRequest.NewContextOptions().setBaseURL(BASE_URL));
    request.post("/api/test/reset");
    request.dispose();
  }

  @AfterAll
  static void closeBrowser() {
    playwright.close();
  }

  @BeforeEach
  void createContextAndPage() {
    context = browser.newContext(new Browser.NewContextOptions().setBaseURL(BASE_URL));
    page = context.newPage();
  }

  @AfterEach
  void closeContext() {
    context.close();
  }

  @Test
  void searchFindsABook() {
    page.navigate("/books");
    page.getByTestId("search-input").fill("quiet");
    page.getByRole(AriaRole.BUTTON, new Page.GetByRoleOptions().setName("Search")).click();
    assertThat(page.getByTestId("book-card")).hasCount(1);
    assertThat(page.getByRole(AriaRole.HEADING, new Page.GetByRoleOptions().setName("The Quiet Compiler"))).isVisible();
  }

  @Test
  void readerAddsAReview() {
    page.navigate("/signin");
    page.getByLabel("Username").fill("reader");
    page.getByLabel("Password").fill(READER_PASSWORD);
    page.getByTestId("signin-submit").click();
    assertThat(page).hasURL(Pattern.compile("/account$"));

    page.navigate("/books/3");
    page.getByLabel("Rating").selectOption("4");
    page.getByLabel("Your review").fill("A lovely, detailed field guide.");
    page.getByRole(AriaRole.BUTTON, new Page.GetByRoleOptions().setName("Submit review")).click();

    Locator review = page.getByTestId("review").filter(new Locator.FilterOptions().setHasText("lovely"));
    assertThat(review).hasAttribute("data-state", "saved");
  }
}

$ export BOOKSHELF_READER_PASSWORD=... BASE_URL=http://localhost:3920
$ mvn -o test
[INFO] Tests run: 2, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 3.059 s -- in demo.BookshelfPlainTest
[INFO] Tests run: 2, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 1.030 s -- in demo.BookshelfJUnitTest
[INFO] Tests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.425 s -- in demo.TracingTest
[INFO] Tests run: 5, Failures: 0, Errors: 0, Skipped: 0
[INFO] BUILD SUCCESS

org.opentest4j.AssertionFailedError:
Locator expected to have count
Expected: 7
Received: 6

Call log:
  - Assert "hasCount" getByTestId("book-card") with timeout 1000ms
  - waiting for getByTestId("book-card")
    11 × locator resolved to 6 elements
       - unexpected value "6"

package demo;

import static com.microsoft.playwright.assertions.PlaywrightAssertions.assertThat;

import com.microsoft.playwright.*;
import com.microsoft.playwright.junit.Options;
import com.microsoft.playwright.junit.OptionsFactory;
import com.microsoft.playwright.junit.UsePlaywright;
import com.microsoft.playwright.options.AriaRole;
import java.nio.file.Paths;
import java.util.regex.Pattern;
import org.junit.jupiter.api.Test;

@UsePlaywright(BookshelfJUnitTest.BookshelfOptions.class)
class BookshelfJUnitTest {
  static final String BASE_URL = System.getenv().getOrDefault("BASE_URL", "http://localhost:3000");

  public static class BookshelfOptions implements OptionsFactory {
    @Override
    public Options getOptions() {
      return new Options()
          .setHeadless(true)
          .setBaseUrl(BASE_URL)
          .setApiRequestOptions(new APIRequest.NewContextOptions().setBaseURL(BASE_URL))
          .setTestIdAttribute("data-testid")
          .setTrace(Options.Trace.RETAIN_ON_FAILURE)
          .setOutputDir(Paths.get("target/playwright-output"));
    }
  }

  @Test
  void readerAddsAReview(Page page, APIRequestContext request) {
    request.post("/api/test/reset");

    page.navigate("/signin");
    page.getByLabel("Username").fill("reader");
    page.getByLabel("Password").fill(System.getenv("BOOKSHELF_READER_PASSWORD"));
    page.getByTestId("signin-submit").click();
    assertThat(page).hasURL(Pattern.compile("/account$"));

    page.navigate("/books/3");
    page.getByLabel("Rating").selectOption("4");
    page.getByLabel("Your review").fill("A lovely, detailed field guide.");
    page.getByRole(AriaRole.BUTTON, new Page.GetByRoleOptions().setName("Submit review")).click();
    assertThat(page.getByTestId("review").filter(new Locator.FilterOptions().setHasText("lovely")))
        .hasAttribute("data-state", "saved");
  }

  @Test
  void searchFindsABook(Page page) {
    page.navigate("/books");
    page.getByTestId("search-input").fill("quiet");
    page.getByRole(AriaRole.BUTTON, new Page.GetByRoleOptions().setName("Search")).click();
    assertThat(page.getByTestId("book-card")).hasCount(1);
  }
}

@Test
void recordsATrace() {
  try (Playwright playwright = Playwright.create()) {
    Browser browser = playwright.chromium().launch();
    BrowserContext context = browser.newContext(new Browser.NewContextOptions().setBaseURL(BASE_URL));
    // Tracing is explicit in library mode: start before the actions, stop with a path to keep it.
    context.tracing().start(new Tracing.StartOptions().setScreenshots(true).setSnapshots(true).setSources(true));
    Page page = context.newPage();
    page.navigate("/books");
    assertThat(page.getByTestId("book-card")).hasCount(6);
    context.tracing().stop(new Tracing.StopOptions().setPath(Paths.get("target/traces/books.zip")));
    browser.close();
  }
}

# src/test/resources/junit-platform.properties
junit.jupiter.execution.parallel.enabled = true
junit.jupiter.execution.parallel.mode.default = same_thread
junit.jupiter.execution.parallel.mode.classes.default = concurrent
junit.jupiter.execution.parallel.config.strategy=dynamic
junit.jupiter.execution.parallel.config.dynamic.factor=0.5

dotnet new nunit -n PlaywrightTests          # or: mstest, xunit, xunit3
cd PlaywrightTests
dotnet add package Microsoft.Playwright.NUnit # or MSTest, MSTest.v4, Xunit, Xunit.v3
dotnet build
pwsh bin/Debug/net8.0/playwright.ps1 install

$ bin/Debug/net10.0/.playwright/node/darwin-arm64/node \
    bin/Debug/net10.0/.playwright/package/cli.js install chromium
$ bin/Debug/net10.0/.playwright/node/darwin-arm64/node \
    bin/Debug/net10.0/.playwright/package/cli.js install --dry-run chromium | head -3
Chrome for Testing 153.0.8010.12 (playwright chromium v1243)
  Install location:    /Users/me/Library/Caches/ms-playwright/chromium-1243
  Download url:        https://cdn.playwright.dev/builds/cft/153.0.8010.12/mac-arm64/chrome-mac-arm64.zip

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <TargetFramework>net10.0</TargetFramework>
    <LangVersion>latest</LangVersion>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
    <IsPackable>false</IsPackable>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="coverlet.collector" Version="6.0.4" />
    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.14.0" />
    <PackageReference Include="Microsoft.Playwright.NUnit" Version="1.63.0" />
    <PackageReference Include="NUnit" Version="4.3.2" />
    <PackageReference Include="NUnit.Analyzers" Version="4.7.0" />
    <PackageReference Include="NUnit3TestAdapter" Version="5.0.0" />
  </ItemGroup>
  <ItemGroup>
    <Using Include="NUnit.Framework" />
  </ItemGroup>
</Project>

using System.Text.RegularExpressions;
using Microsoft.Playwright;
using Microsoft.Playwright.NUnit;

namespace Bookshelf.Tests;

[Parallelizable(ParallelScope.Self)]
[TestFixture]
public class BookshelfTests : PageTest
{
    private static readonly string BaseUrl =
        Environment.GetEnvironmentVariable("BASE_URL") ?? "http://localhost:3000";

    private static readonly string ReaderPassword =
        Environment.GetEnvironmentVariable("BOOKSHELF_READER_PASSWORD")
        ?? throw new InvalidOperationException("Set BOOKSHELF_READER_PASSWORD");

    public override BrowserNewContextOptions ContextOptions() => new()
    {
        BaseURL = BaseUrl,
        Locale = "en-GB",
    };

    [SetUp]
    public async Task ResetData()
    {
        // Arrange through the HTTP API, not the UI.
        var request = await Playwright.APIRequest.NewContextAsync(new() { BaseURL = BaseUrl });
        await request.PostAsync("/api/test/reset");
        await request.DisposeAsync();
    }

    [Test]
    public async Task SearchFindsABook()
    {
        await Page.GotoAsync("/books");
        await Page.GetByTestId("search-input").FillAsync("quiet");
        await Page.GetByRole(AriaRole.Button, new() { Name = "Search" }).ClickAsync();
        await Expect(Page.GetByTestId("book-card")).ToHaveCountAsync(1);
        await Expect(Page.GetByRole(AriaRole.Heading, new() { Name = "The Quiet Compiler" })).ToBeVisibleAsync();
    }

    [Test]
    public async Task ReaderAddsAReview()
    {
        await Page.GotoAsync("/signin");
        await Page.GetByLabel("Username").FillAsync("reader");
        await Page.GetByLabel("Password").FillAsync(ReaderPassword);
        await Page.GetByTestId("signin-submit").ClickAsync();
        await Expect(Page).ToHaveURLAsync(new Regex("/account$"));

        await Page.GotoAsync("/books/3");
        await Page.GetByLabel("Rating").SelectOptionAsync("4");
        await Page.GetByLabel("Your review").FillAsync("A lovely, detailed field guide.");
        await Page.GetByRole(AriaRole.Button, new() { Name = "Submit review" }).ClickAsync();

        var review = Page.GetByTestId("review").Filter(new() { HasText = "lovely" });
        await Expect(review).ToHaveAttributeAsync("data-state", "saved");
    }
}

$ export BOOKSHELF_READER_PASSWORD=... BASE_URL=http://localhost:3920
$ dotnet test
Passed!  - Failed:     0, Passed:     2, Skipped:     0, Total:     2, Duration: 2 s - NUnitTests.dll (net10.0)

<Project Sdk="Microsoft.NET.Sdk">
  <PropertyGroup>
    <OutputType>Exe</OutputType>
    <TargetFramework>net10.0</TargetFramework>
    <ImplicitUsings>enable</ImplicitUsings>
    <Nullable>enable</Nullable>
    <IsPackable>false</IsPackable>
  </PropertyGroup>
  <ItemGroup>
    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.14.1" />
    <PackageReference Include="Microsoft.Playwright.Xunit.v3" Version="1.63.0" />
    <PackageReference Include="xunit.v3" Version="3.2.2" />
    <PackageReference Include="xunit.runner.visualstudio" Version="3.1.4" />
  </ItemGroup>
  <ItemGroup>
    <Using Include="Xunit" />
  </ItemGroup>
</Project>

using System.Text.RegularExpressions;
using Microsoft.Playwright;
using Microsoft.Playwright.MSTest;

namespace Bookshelf.Tests;

[TestClass]
public class BookshelfTests : PageTest
{
    public override BrowserNewContextOptions ContextOptions() => new()
    {
        BaseURL = Environment.GetEnvironmentVariable("BASE_URL") ?? "http://localhost:3000",
        Locale = "en-GB",
    };

    [TestMethod]
    public Task SearchFindsABook() => SearchFindsABookBody();

    [TestMethod]
    public Task ReaderAddsAReview() => ReaderAddsAReviewBody();

    // SearchFindsABookBody() and ReaderAddsAReviewBody() hold the steps shown for NUnit.
}

<?xml version="1.0" encoding="utf-8"?>
<RunSettings>
  <NUnit>
    <NumberOfTestWorkers>2</NumberOfTestWorkers>
  </NUnit>
  <RunConfiguration>
    <EnvironmentVariables>
      <DEBUG>pw:api</DEBUG>
    </EnvironmentVariables>
  </RunConfiguration>
  <Playwright>
    <BrowserName>webkit</BrowserName>
    <ExpectTimeout>5000</ExpectTimeout>
    <LaunchOptions>
      <Headless>true</Headless>
    </LaunchOptions>
  </Playwright>
</RunSettings>

$ BROWSER=webkit dotnet test --no-build
Passed!  - Failed:     0, Passed:     2, Skipped:     0, Total:     2, Duration: 1 s - NUnitTests.dll (net10.0)

$ dotnet test --no-build -- Playwright.BrowserName=webkit Playwright.LaunchOptions.Headless=true NUnit.NumberOfTestWorkers=2
Passed!  - Failed:     0, Passed:     2, Skipped:     0, Total:     2, Duration: 1 s - NUnitTests.dll (net10.0)

$ dotnet test --no-build --settings bookshelf.runsettings --logger "console;verbosity=detailed"
2026-10-25T19:58:18.017Z pw:api → POST http://localhost:3920/api/test/reset
...
Passed!  - Failed:     0, Passed:     2, Skipped:     0, Total:     2, Duration: 2 s - NUnitTests.dll (net10.0)

using Microsoft.Playwright;
using Microsoft.Playwright.NUnit;

namespace Bookshelf.Tests;

[Parallelizable(ParallelScope.Self)]
[TestFixture]
public class TracedTests : PageTest
{
    public override BrowserNewContextOptions ContextOptions() => new()
    {
        BaseURL = Environment.GetEnvironmentVariable("BASE_URL") ?? "http://localhost:3000",
    };

    [SetUp]
    public async Task StartTracing()
    {
        // The NUnit base classes have no tracing switch: start it per test.
        await Context.Tracing.StartAsync(new() { Screenshots = true, Snapshots = true, Sources = true });
    }

    [TearDown]
    public async Task StopTracing()
    {
        var failed = TestContext.CurrentContext.Result.Outcome.Status == NUnit.Framework.Interfaces.TestStatus.Failed;
        await Context.Tracing.StopAsync(new()
        {
            // Keep the trace only for failing tests.
            Path = failed ? Path.Combine(TestContext.CurrentContext.WorkDirectory, "traces",
                $"{TestContext.CurrentContext.Test.Name}.zip") : null,
        });
    }

    [Test]
    public async Task CatalogueShowsSixBooksPerPage()
    {
        await Page.GotoAsync("/books");
        await Expect(Page.GetByTestId("book-card")).ToHaveCountAsync(6);
    }

    [Test, Explicit("Fails on purpose to show the kept trace")]
    public async Task FailingTestKeepsItsTrace()
    {
        await Page.GotoAsync("/books");
        await Expect(Page.GetByTestId("book-card")).ToHaveCountAsync(7, new() { Timeout = 1000 });
    }
}

$ dotnet test
Passed!  - Failed:     0, Passed:     3, Skipped:     0, Total:     3, Duration: 957 ms - NUnitTests.dll (net10.0)
$ dotnet test --filter "Name=FailingTestKeepsItsTrace"
Failed!  - Failed:     1, Passed:     0, Skipped:     0, Total:     1
  Microsoft.Playwright.PlaywrightException : Locator expected to have count '7'
Call log:
  - waiting for GetByTestId("book-card")
    11 × locator resolved to 6 elements
       - unexpected value "6"
$ ls bin/Debug/net10.0/traces
FailingTestKeepsItsTrace.zip