One concept: a dict - a labelled bag of values you look up by key. One skill: drive a .fill() from a dict value instead of a bare string literal.

So far your test values were loose strings scattered through the test. A dict groups related values under names: member = {"username": "naruto", "password": "ramen"}. You read a value with its key in square brackets: member["username"] gives "naruto". This is your first step toward clean test data - the credentials live in one labelled place, not spread across the file. Use them to log in: fill the username field with member["username"] and the password field with member["password"], then submit. The login flow is the same one you wrote in A6; only where the values come from has changed.

from playwright.sync_api import Page, expect


def test_login_from_dict(page: Page):
    page.goto("/dojo/app/index.html")
    # TODO: store the member's password in this dict. The valid member is
    #       username "naruto", password "ramen". Replace the empty string.
    member = {"username": "naruto", "password": ""}
    page.get_by_role("button", name="Log in").click()
    page.get_by_label("Username").fill(member["username"])
    page.get_by_label("Password").fill(member["password"])
    page.get_by_role("button", name="Sign in").click()
    expect(page.get_by_test_id("member-bar")).to_be_visible()

from playwright.sync_api import Page, expect


def test_login_from_dict(page: Page):
    page.goto("/dojo/app/index.html")
    member = {"username": "naruto", "password": "ramen"}
    page.get_by_role("button", name="Log in").click()
    page.get_by_label("Username").fill(member["username"])
    page.get_by_label("Password").fill(member["password"])
    page.get_by_role("button", name="Sign in").click()
    expect(page.get_by_test_id("member-bar")).to_be_visible()

One concept: a class with __init__(self, page) - a blueprint you build with the page handed in. One skill: none brand new on the Playwright side; the locators are the same A6 ones, now grouped inside a class.

A class is a blueprint. class LoginPage: defines one; LoginPage(page) builds one. When you build it, Python runs __init__, the setup method. Its first parameter is always self (the object being built, covered next level); its second here is page, the browser handed in so the class can build its locators. For now, just gather the login page's four locators inside __init__. The win is grouping: every login locator lives in one file, pages/login_page_g2.py, instead of being retyped in each test. This level only builds the class. Making the locators reusable from methods is the very next step.

class LoginPage:
    # TODO: __init__ needs the page handed to it so it can build locators.
    #       Add the page parameter:  def __init__(self, page):
    def __init__(self):
        open_button = page.get_by_role("button", name="Log in")
        username = page.get_by_label("Username")
        password = page.get_by_label("Password")
        submit = page.get_by_role("button", name="Sign in")

from playwright.sync_api import Page, expect
from pages.login_page_g2 import LoginPage


def test_login_page_object_builds(page: Page):
    page.goto("/dojo/app/index.html")
    login = LoginPage(page)
    # The class built without error: the four login locators now live in one place.
    assert isinstance(login, LoginPage)
    # The page still works the plain way; the class did not break anything.
    expect(page.get_by_role("button", name="Log in")).to_be_visible()

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

One concept: self and instance attributes - store values on self.x so every method on the object can reuse them. This is the Python beginner cliff, so it is its own level by design. One skill: none brand new; you reuse .click() and .fill() inside a method.

Last level the locators vanished when __init__ finished, because they were plain local variables. To keep them, attach them to the object with self: self.username = .... self is the object being built; anything you put on self survives and is reachable from every method. That is why every method takes self as its first parameter - it is how the method gets back to the same object's stored locators. Store the four login locators on self, then write one method, login(self, username, password), that reuses self.open_button, self.username, self.password, and self.submit. The test then reads as one line: login.login("naruto", "ramen").

Why every method takes self (read this slowly). self is not magic and not a keyword - it is just the name of the first parameter, and by convention we always call it self. When you write login.login("naruto", "ramen"), Python turns it into LoginPage.login(login, "naruto", "ramen") behind the scenes - it passes the object itself in as the first argument. So inside the method, self IS that object, and self.username is the locator you stored in __init__. Forget the self. prefix and the value is a throwaway local again, gone the moment the method ends. That is the single idea this level exists to drill.

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")
        # TODO: store the "Sign in" submit button on self so login() can click it.
        #       self.submit = page.get_by_role("button", name="Sign in")
        self.submit = None

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

from playwright.sync_api import Page, expect
from pages.login_page_g3 import LoginPage


def test_login_method(page: Page):
    page.goto("/dojo/app/index.html")
    login = LoginPage(page)
    login.login("naruto", "ramen")
    expect(page.get_by_test_id("member-bar")).to_be_visible()

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")

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

One concept: none brand new; you combine the class + self ideas by writing and using a SECOND page object alongside the first. One skill: a capstone test that touches NO raw locator - it reads only through page objects.

One page object is a tool; the point of POM is that a whole test reads through them. Add a second class, MenuPage, the same way you built LoginPage: locators on self in __init__, and an add_bowl(self, bowl_name) method that clicks that bowl's add button (the f-string name from A8, now inside a method). The capstone test builds both page objects, logs in through LoginPage, adds a bowl through MenuPage, and checks the cart count - and it never writes a raw get_by_* of its own. That is the payoff: tests read like sentences, and every locator has exactly one home.

This capstone has TWO small additions across two files, both stated up front - no hidden pieces. Do them in order.

        self.member_bar = page.get_by_test_id("member-bar")

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")
        # TODO (Addition 1): store the member bar so the capstone can read
        #       login state through the page object:
        #       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):
        # TODO: click the "Add <bowl_name> to cart" button for this bowl.
        #       Build the name with an f-string, the way you did in Academy A8.
        pass

from playwright.sync_api import Page, expect
from pages.login_page_g4 import LoginPage
from pages.menu_page_g4 import MenuPage


def test_member_adds_a_bowl(page: Page):
    page.goto("/dojo/app/index.html")
    login = LoginPage(page)
    menu = MenuPage(page)

    login.login("naruto", "ramen")
    expect(login.member_bar).to_be_visible()

    menu.add_bowl("Miso Ramen")
    expect(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()

One concept: @pytest.mark.parametrize - run the SAME test once per row of input data, so different inputs are checked without copying the test. One skill: the parametrize decorator plus the matching test arguments.

In A6 your if/else branched, but the input was fixed, so only one branch ever ran. Real suites need to check many inputs. @pytest.mark.parametrize does that: you list the parameter names and a list of rows, and pytest runs the test once per row, passing each row's values in as arguments. Here you test login with three rows: the valid member, a wrong password, and a wrong username. Each row carries what to expect (member bar visible or hidden), so the data itself decides the assertion. One test body, three real runs. If a fourth case matters tomorrow, you add a row, not a test.

import pytest
from playwright.sync_api import Page, expect


@pytest.mark.parametrize("username, password, expect_member", [
    ("naruto", "ramen", True),
    # TODO: a wrong password must NOT show the member bar. Fix the expected
    #       value below from True to the correct boolean for this row.
    ("naruto", "wrong", True),
    ("sasuke", "ramen", False),
])
def test_login_rows(page: Page, username, password, expect_member):
    page.goto("/dojo/app/index.html")
    page.get_by_role("button", name="Log in").click()
    page.get_by_label("Username").fill(username)
    page.get_by_label("Password").fill(password)
    page.get_by_role("button", name="Sign in").click()
    member_bar = page.get_by_test_id("member-bar")
    if expect_member:
        expect(member_bar).to_be_visible()
    else:
        expect(member_bar).to_be_hidden()

import pytest
from playwright.sync_api import Page, expect


@pytest.mark.parametrize("username, password, expect_member", [
    ("naruto", "ramen", True),
    ("naruto", "wrong", False),
    ("sasuke", "ramen", False),
])
def test_login_rows(page: Page, username, password, expect_member):
    page.goto("/dojo/app/index.html")
    page.get_by_role("button", name="Log in").click()
    page.get_by_label("Username").fill(username)
    page.get_by_label("Password").fill(password)
    page.get_by_role("button", name="Sign in").click()
    member_bar = page.get_by_test_id("member-bar")
    if expect_member:
        expect(member_bar).to_be_visible()
    else:
        expect(member_bar).to_be_hidden()

One concept: none brand new; a second parametrize rep over a different data shape (a code in, an exact message out). One skill: none brand new; you reuse the cart -> checkout flow and to_have_text, driven by parametrize rows.

One parametrize was the lesson; this one is the rep, on different data. IchiRamen's checkout form has a promo box. Three codes each show their own success message: RAMEN10, FREESHIP, and NARUTO. Parametrize one test over (code, message) rows: for each code, add a bowl, open the cart, go to checkout, type the code, click Apply, and assert the promo message reads exactly that row's text. Same body, three codes, three checks. This is the everyday use of parametrize: a table of input and expected output, one test that walks it.

import pytest
from playwright.sync_api import Page, expect


@pytest.mark.parametrize("code, message", [
    ("RAMEN10", "10% discount applied!"),
    # TODO: FREESHIP shows a different success message. Fill in the exact
    #       text the app shows for FREESHIP (replace the empty string).
    ("FREESHIP", ""),
    ("NARUTO", "$5 discount applied!"),
])
def test_promo_code_message(page: Page, code, message):
    page.goto("/dojo/app/index.html")
    page.get_by_role("button", name="Add Miso Ramen to cart").click()
    page.get_by_role("button", name="Shopping cart").click()
    page.get_by_role("button", name="Checkout").click()
    page.get_by_label("Promo code").fill(code)
    page.get_by_role("button", name="Apply").click()
    expect(page.get_by_test_id("promo-message")).to_have_text(message)

import pytest
from playwright.sync_api import Page, expect


@pytest.mark.parametrize("code, message", [
    ("RAMEN10", "10% discount applied!"),
    ("FREESHIP", "Free shipping applied!"),
    ("NARUTO", "$5 discount applied!"),
])
def test_promo_code_message(page: Page, code, message):
    page.goto("/dojo/app/index.html")
    page.get_by_role("button", name="Add Miso Ramen to cart").click()
    page.get_by_role("button", name="Shopping cart").click()
    page.get_by_role("button", name="Checkout").click()
    page.get_by_label("Promo code").fill(code)
    page.get_by_role("button", name="Apply").click()
    expect(page.get_by_test_id("promo-message")).to_have_text(message)