It’s 2 AM. The CI pipeline has just failed — again — because of E2E test timeouts. You open the Allure report and see that 47 out of 50 test cases were stuck on the login page for over 8 seconds. Your team is writing automated tests with Playwright, but every single test goes through the entire login flow from scratch: type username, type password, click the button, wait for the redirect. You think, “Isn’t this just burning time and money for nothing?” What’s even more absurd is that no one thought about saving and reusing the login state.

That’s what we’re covering today: using Playwright’s storageState together with pytest’s fixture mechanism to compress repeated logins into a single one, while extracting the assertion logic into reusable “memory modules” to make your test code shorter and more stable.

Breaking Down the Problem

The scenario is all too common: you have an admin system (like an operations panel or SaaS console) that requires login to access. You’ve written 50 P0-level functional tests. The simplest approach puts page.goto('/login') in every case, fills the form, logs in, and then tests the actual business logic. The results:

• Execution time explodes: The average login takes 2.3 seconds (including page load, typing, clicking, waiting for the dashboard). 50 test cases devour 115 seconds just logging in, and with CI resource queuing, one run easily exceeds 8 minutes.
• Maintenance hell: The moment a login page selector changes, every single case must be updated. For example, if the button changes from #login-btn to [data-testid="submit"], you need a global search-and-replace. Miss one and a whole bunch of tests fail.
• Assertion duplication: Almost every case contains similar expect(page.locator('.toast')).to_have_text('Success') checks. The same validation logic is scattered everywhere. Adding a new case means copy-pasting assertions, so a slight toast text change can break a dozen tests.

The root cause is clear: the tests don’t separate “state” from “behavior.” Login is a prerequisite state, not a business behavior — it should be shared. Assertions are checks against page state and should be encapsulated as domain language, not littered with locators and raw strings.

What about the usual workarounds? Some people use setUp to log in before each test and tearDown to log out — but that still performs the login every time, only deduplicating the code, which treats the symptom but not the cause. Others manually paste cookies into the code, but the moment a token expires everything breaks. We need an automated, refreshable, cross-case reusable login state solution, while also making assertions as callable as a library.

Solution Design

The technical choice is straightforward: Playwright natively offers context.storage_state(), which serializes cookies, localStorage, and IndexedDB of the current browser context into a JSON file. Next time you load it with browser.new_context(storage_state=path), it restores the login state directly, completely bypassing the login page.

Architecturally, we use pytest fixture scopes to achieve different levels of sharing:

• session-scoped fixture: responsible for generating storage_state.json. If the file already exists and hasn’t expired, it reuses it directly; otherwise it performs a single login and saves the state.
• function-scoped fixture: each test case derives a fresh page from the already-logged-in context, so tests remain isolated from each other and won’t pollute one another.
• Reusable assertion module: common checks like toast verification, table row count, modal text are wrapped as independent functions living in assertions.py, called uniformly by all tests.

Why not other approaches?

• Not storing cookies in a global variable: cookies can be large, and localStorage / IndexedDB data can’t be reliably captured that way; storageState fully serializes everything.
• Not using pytest-xdist’s group_scope: although it can share fixtures across workers, it requires an extra plugin and has concurrency issues when reading/writing the storageState file. A single session-scoped fixture with a locking mechanism is more stable.
• Not calling an API to get a token and then setting localStorage in every case: some systems bind tokens to browser fingerprints, so simply setting them may not work. Following the full login flow is more reliable.

With this design, 50 test cases need only a single real login, and all assertion logic converges into 3–5 functions. Maintenance effort is slashed by half.

Core Implementation

1. Session-Scoped Fixture: “Login Once, Use Everywhere”

What this code does: it runs the login only once during the entire pytest lifecycle and persists the browser state to a temporary file. On subsequent test runs, if the state file exists and the token has not expired, it loads directly and skips login.

# conftest.py
import json
import os
import time
import pytest
from playwright.sync_api import sync_playwright, Browser, BrowserContext

STATE_FILE = "storage_state.json"
TOKEN_EXPIRE_SECONDS = 7200  # 假设 token 有效期 2 小时

@pytest.fixture(scope="session")
def playwright_instance():
    with sync_playwright() as p:
        yield p

@pytest.fixture(scope="session")
def browser(playwright_instance):
    # 这里用 headless 模式，CI 环境友好
    browser = playwright_instance.chromium.launch(headless=True)
    yield browser
    browser.close()

@pytest.fixture(scope="session")
def logged_in_context(browser: Browser) -> BrowserContext:
    # 状态文件如果存在且未过期，直接复用
    if os.path.exists(STATE_FILE):
        mtime = os.path.getmtime(STATE_FILE)
        if time.time() - mtime < TOKEN_EXPIRE_SECONDS:
            context = browser.new_context(storage_state=STATE_FILE)
            yield context
            context.close()
            return

    # 否则走完整登录流程
    conte