End-to-End Tests

An end-to-end test drives the real application the way a person would. It opens a browser, fills in the form, clicks the button and reads the page.

Nothing else gives you that evidence. Every other test in this course substitutes something: a double for a dependency, an in-process host for a deployment, an HttpClient for a browser. An end-to-end test substitutes nothing, so when it passes you know the whole assembled system did the job — the JavaScript, the CSS that positions the button, the API, the database, the configuration of the environment it ran against.

It is also the slowest and most fragile kind of test you can write, by a wide margin. Both statements are true at once, and that is what makes the number of them a decision rather than a preference.

using Microsoft.Playwright;
using Xunit;
using static Microsoft.Playwright.Assertions;

public class PlaceOrderJourney : IAsyncLifetime
{
    private IPlaywright _playwright = null!;
    private IBrowser _browser = null!;

    public async Task InitializeAsync()
    {
        _playwright = await Playwright.CreateAsync();
        _browser = await _playwright.Chromium.LaunchAsync();
    }

    [Fact]
    public async Task ACustomerCanPlaceAnOrderAndSeeItConfirmed()
    {
        IPage page = await _browser.NewPageAsync();
        await page.GotoAsync("https://staging.example.internal/orders/new");

        // Act — the journey, as a person would perform it
        await page.GetByLabel("Product").SelectOptionAsync("Desk lamp");
        await page.GetByLabel("Quantity").FillAsync("8");
        await page.GetByRole(AriaRole.Button, new() { Name = "Place order" }).ClickAsync();

        // Assert — wait for the outcome, never for a duration
        await Expect(page.GetByRole(AriaRole.Heading, new() { Name = "Order confirmed" }))
            .ToBeVisibleAsync();
        await Expect(page.GetByTestId("order-total")).ToHaveTextAsync("200.00");
    }

    public async Task DisposeAsync()
    {
        await _browser.DisposeAsync();
        _playwright.Dispose();
    }
}

• GetByLabel and GetByRole find elements the way a person or a screen reader does — by visible label and by role. A CSS path such as div.form > div:nth-child(3) input breaks the next time somebody adds a wrapper, and it tells a reader nothing.
• GetByTestId is the escape hatch for a value with no accessible name of its own, like a computed total. Add an explicit test identifier in the markup rather than reaching for a class name that exists for styling and may change for styling reasons.
• Expect(...).ToBeVisibleAsync retries until the condition holds or a timeout expires. That retry is what makes the test tolerate a request that takes 200ms one run and 900ms the next.
• There is no sleep anywhere. A fixed wait is either too short, which is a flaky failure, or too long, which is time added to every run forever. Wait for the state you expect.
• The browser is launched once for the class and a fresh page is opened per test, so tests do not inherit each other's cookies or local storage. Launching a browser is the most expensive part of the run.
• Headless is the default, which is what you want in a pipeline. Pass LaunchAsync(new() { Headless = false }) locally when you need to watch what happens.

Where these run matters as much as how many there are. A small smoke set — sign in, place an order — belongs on every deployment, because it answers the one question a deployment raises: is the thing that just went out usable? The rest can run on a schedule, nightly or before a release, where a twenty-minute suite costs nobody's attention.

Expect to maintain them. An interface changes more often than a domain rule, and every change can move a selector. Budget for that rather than being surprised by it, and treat a test that needs constant attention as a candidate for deletion once cheaper tests cover the same behaviour.

One last honest note: a failing end-to-end test usually needs a person. It tells you the journey is broken, not which of eight components broke it. That is the price of the only test that checks the assembled whole, and it is a reasonable price to pay a small number of times.