One concept: the built-in fixtures - page, context, and browser are things pytest-playwright hands you by name; conftest.py is where shared fixtures live. One skill: none new on the Playwright side; you only ask for two more built-in fixtures and see how they relate.

Every test so far asked for page in its parentheses. page is a fixture: a ready-made value pytest-playwright builds and hands you. There are two more you can ask for the same way. context is the browser context the page lives in (its own cookies and storage). browser is the whole browser the context runs in. The nesting is simple: a browser holds contexts, and a context holds pages. You never build these; you name them. conftest.py is the shared file where your own fixtures live so every test can use them, which is exactly what the next levels do.

from playwright.sync_api import Page, BrowserContext, Browser, expect


def test_builtin_fixtures_are_related(page: Page, context: BrowserContext, browser: Browser):
    page.goto("/dojo/app/index.html")
    expect(page.get_by_role("heading", name="Tonight's Bowls")).to_be_visible()
    # TODO: the page lives inside the context. Replace None so this checks that
    #       page.context is the same context fixture you were handed.
    #       assert page.context is context
    assert None is context
    assert context.browser is browser

from playwright.sync_api import Page, BrowserContext, Browser, expect


def test_builtin_fixtures_are_related(page: Page, context: BrowserContext, browser: Browser):
    page.goto("/dojo/app/index.html")
    expect(page.get_by_role("heading", name="Tonight's Bowls")).to_be_visible()
    assert page.context is context
    assert context.browser is browser

One concept: storageState - capture a logged-in session to a file once, then start later contexts already logged in instead of repeating the login flow. One skill: page.context.storage_state(path=...) to save, and a browser_context_args override with "storage_state": ... to reuse. This is the headline Chunin skill.

Logging in on every test is slow and repetitive. Do it ONCE. A setup test logs in, then calls page.context.storage_state(path="auth/state.json"), which writes the session cookie to a file. Other tests then start from that file: override the browser_context_args fixture to return {"storage_state": "auth/state.json"}, and every context begins already logged in. IchiRamen stores its session in a cookie scoped to /dojo/app, and on load it reads that cookie and shows the member bar. So a reused context shows the member bar with no login steps at all. That is real auth reuse, the way large suites avoid logging in a thousand times.

from playwright.sync_api import Page, expect


def test_capture_logged_in_state(page: Page):
    page.goto("/dojo/app/index.html")
    page.get_by_role("button", name="Log in").click()
    page.get_by_label("Username").fill("naruto")
    page.get_by_label("Password").fill("ramen")
    page.get_by_role("button", name="Sign in").click()
    expect(page.get_by_test_id("member-bar")).to_be_visible()
    page.context.storage_state(path="auth/state.json")

{"cookies": [{"name": "ichiramen_session", "value": "naruto", "domain": "localhost",
"path": "/dojo/app", "expires": 1782648044.375293, "httpOnly": false, "secure": false,
"sameSite": "Lax"}], "origins": []}

import pytest
from playwright.sync_api import Page, expect


@pytest.fixture(scope="session")
def browser_context_args(browser_context_args):
    # TODO: reuse the captured session. Add "storage_state": "auth/state.json"
    #       to the returned dict so this context starts already logged in.
    return {**browser_context_args}


def test_member_bar_without_logging_in(page: Page):
    page.goto("/dojo/app/index.html")
    expect(page.get_by_test_id("member-bar")).to_be_visible()

import pytest
from playwright.sync_api import Page, expect


@pytest.fixture(scope="session")
def browser_context_args(browser_context_args):
    return {**browser_context_args, "storage_state": "auth/state.json"}


def test_member_bar_without_logging_in(page: Page):
    page.goto("/dojo/app/index.html")
    # No login flow here. The restored cookie shows the member bar on load.
    expect(page.get_by_test_id("member-bar")).to_be_visible()


def test_member_name_is_restored(page: Page):
    page.goto("/dojo/app/index.html")
    expect(page.get_by_test_id("member-bar")).to_contain_text("naruto")

One concept: writing your own @pytest.fixture - a named setup that hands a ready value to any test that asks for it by name. This is the only custom decorator Chunin teaches. One skill: a fixture that returns a ready, logged-in page object so the test body is one line.

In C2 you overrode a built-in fixture. Now write your own. A @pytest.fixture is a function that prepares something and hands it back with return. Any test that names it in its parameters receives that value. Here, write logged_in_menu: it opens IchiRamen, logs in through your Genin LoginPage, and returns a ready MenuPage. A test that asks for logged_in_menu skips all the setup and goes straight to the action. This is how real suites stop repeating themselves: setup lives in one fixture, and tests read as pure intent. The fixture is the setup; the test is the check.

import pytest
from playwright.sync_api import Page, expect
from pages.login_page import LoginPage
from pages.menu_page import MenuPage


@pytest.fixture
def logged_in_menu(page: Page):
    page.goto("/dojo/app/index.html")
    LoginPage(page).login("naruto", "ramen")
    # TODO: a fixture hands back a value with `return`. Return a MenuPage
    #       built on this page so the test receives a ready page object.
    #       return MenuPage(page)


def test_member_adds_a_bowl(logged_in_menu):
    logged_in_menu.add_bowl("Miso Ramen")
    expect(logged_in_menu.cart_count).to_have_text("1")

class LoginPage:
    def __init__(self, page):
        self.page = page
        self.open_button = page.get_by_role("button", name="Log in")
        self.username = page.get_by_label("Username")
        self.password = page.get_by_label("Password")
        self.submit = page.get_by_role("button", name="Sign in")
        self.member_bar = page.get_by_test_id("member-bar")

    def login(self, username, password):
        self.open_button.click()
        self.username.fill(username)
        self.password.fill(password)
        self.submit.click()

class MenuPage:
    def __init__(self, page):
        self.page = page
        self.cart_count = page.get_by_test_id("cart-count")

    def add_bowl(self, bowl_name):
        self.page.get_by_role("button", name=f"Add {bowl_name} to cart").click()

import pytest
from playwright.sync_api import Page, expect
from pages.login_page import LoginPage
from pages.menu_page import MenuPage


@pytest.fixture
def logged_in_menu(page: Page):
    page.goto("/dojo/app/index.html")
    LoginPage(page).login("naruto", "ramen")
    return MenuPage(page)


def test_member_adds_a_bowl(logged_in_menu):
    logged_in_menu.add_bowl("Miso Ramen")
    expect(logged_in_menu.cart_count).to_have_text("1")

One concept: none brand new; you reuse class + self to wrap a SUB-REGION of the page (a component) instead of a whole page. One skill: scoping a component's locators to its region with self.panel.get_by_role(...), so the component only ever matches inside the cart.

A page object covers a page; a component object covers one repeating region of it. The cart panel is perfect: it has its own items, quantity buttons, and a remove button per line. Wrap it in a CartComponent. Store the panel itself as self.panel = page.get_by_label("Cart panel"), then build every other locator INSIDE that panel: self.panel.get_by_role("button", name=f"Remove {bowl_name} from cart"). Scoping to the panel keeps the component honest, it cannot accidentally match a button elsewhere on the page. Tests then read like sentences: cart.remove("Miso Ramen"). Components are how real suites stay tidy when one region shows up across many tests.

class CartComponent:
    def __init__(self, page):
        self.page = page
        self.panel = page.get_by_label("Cart panel")
        self.open_button = page.get_by_role("button", name="Shopping cart")
        self.count = page.get_by_test_id("cart-count")

    def open(self):
        self.open_button.click()

    def remove(self, bowl_name):
        # TODO: click the "Remove <bowl_name> from cart" button INSIDE the
        #       panel. Scope it to self.panel so it does not match elsewhere.
        #       self.panel.get_by_role("button", name=f"Remove {bowl_name} from cart").click()
        pass

    def line_item(self, bowl_name):
        return self.panel.get_by_text(bowl_name, exact=True)

from playwright.sync_api import Page, expect
from pages.menu_page import MenuPage
from pages.cart_component import CartComponent


def test_remove_one_bowl_from_cart(page: Page):
    page.goto("/dojo/app/index.html")
    menu = MenuPage(page)
    cart = CartComponent(page)

    menu.add_bowl("Miso Ramen")
    menu.add_bowl("Tonkotsu")
    cart.open()

    # Both bowls are in the cart, count reads 2.
    expect(cart.count).to_have_text("2")
    expect(cart.line_item("Miso Ramen")).to_be_visible()

    # Remove one through the component; the panel updates.
    cart.remove("Miso Ramen")
    expect(cart.count).to_have_text("1")
    expect(cart.line_item("Miso Ramen")).to_be_hidden()

class CartComponent:
    def __init__(self, page):
        self.page = page
        # Everything below is scoped to the cart panel region, not the whole page.
        self.panel = page.get_by_label("Cart panel")
        self.open_button = page.get_by_role("button", name="Shopping cart")
        self.count = page.get_by_test_id("cart-count")

    def open(self):
        self.open_button.click()

    def remove(self, bowl_name):
        self.panel.get_by_role("button", name=f"Remove {bowl_name} from cart").click()

    def line_item(self, bowl_name):
        return self.panel.get_by_text(bowl_name, exact=True)