# Playwright (Python) — sync API
# Good for scripts, scraping, and one-off automation

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch(headless=True)
    page = browser.new_page()

    page.goto("https://example.com/products")

    # Auto-waits until the table is present
    page.wait_for_selector("table.data")

    rows = []
    for tr in page.locator("table.data tbody tr").all():
        cells = [c.inner_text().strip() for c in tr.locator("td").all()]
        if cells:
            rows.append(cells)

    print(f"Scraped {len(rows)} rows")
    print(rows[:3])

    browser.close()

# Playwright (Python) — async API
# Good for FastAPI services, concurrent scrapers, modern Python code

import asyncio
from playwright.async_api import async_playwright

async def scrape(url: str) -> list[dict]:
    async with async_playwright() as p:
        browser = await p.chromium.launch(headless=True)
        page = await browser.new_page()
        await page.goto(url, wait_until="networkidle")

        items = []
        for card in await page.locator(".listing-card").all():
            title = await card.locator(".title").inner_text()
            price = await card.locator(".price").inner_text()
            items.append({"title": title, "price": price})

        await browser.close()
        return items

async def main():
    results = await asyncio.gather(
        scrape("https://example.com/a"),
        scrape("https://example.com/b"),
    )
    print("Total items:", sum(len(r) for r in results))

asyncio.run(main())

# Playwright + Pytest — a real end-to-end test
# File: tests/test_login.py

import re
import pytest
from playwright.sync_api import Page, expect

@pytest.fixture
def app_url() -> str:
    return "https://the-internet.herokuapp.com/login"

def test_login_succeeds(page: Page, app_url: str) -> None:
    page.goto(app_url)

    page.get_by_label("Username").fill("tomsmith")
    page.get_by_label("Password").fill("SuperSecretPassword!")
    page.get_by_role("button", name="Login").click()

    expect(page).to_have_url(re.compile("/secure"))
    expect(page.locator(".flash.success")).to_contain_text("You logged into")

def test_login_fails_with_wrong_password(page: Page, app_url: str) -> None:
    page.goto(app_url)

    page.get_by_label("Username").fill("tomsmith")
    page.get_by_label("Password").fill("wrong")
    page.get_by_role("button", name="Login").click()

    expect(page.locator(".flash.error")).to_contain_text("invalid")

# Run: pytest --headed  (or without --headed for headless)

# Project 1 — E2E test suite for a FastAPI app
# README outline

Problem:
"My FastAPI notes app has no end-to-end tests.
Broken flows reach users unnoticed."

Stack:
- App: FastAPI + SQLite (already built)
- Tests: Playwright + Pytest + GitHub Actions
- Locators: role-based for resilience

What the suite covers:
1. Sign up → login → create a note → logout
2. Login with wrong password fails clearly
3. Note list is paginated correctly
4. A shared fixture resets the database per test

Results:
- 12 tests, average runtime under 30s
- Runs on every PR via GitHub Actions
- Traces uploaded as artifacts on failure

Skills shown:
- Playwright, Pytest, page fixtures
- CI automation, trace viewer
- Real production-quality testing

# Project 2 — Async scraper for a public catalog
# README outline

Problem:
"I need fresh product data weekly, but the source
has no API. Manual downloading is slow and error-prone."

Stack:
- Playwright (async) + Pydantic + httpx
- CSV output, GitHub Action weekly schedule

Steps:
1. Concurrently scrape 5 category pages
2. Parse each product into a typed Pydantic model
3. Validate: prices > 0, names non-empty
4. Export to CSV, commit to repo
5. Alert on record-count delta > 20%

Results:
- ~1,500 products scraped in under a minute
- Weekly refresh without manual work
- Data passes schema validation every run

Skills shown:
- Async Playwright, asyncio.gather
- Pydantic schemas, retries
- CI-scheduled automation

# A polite Playwright scraper skeleton
import asyncio, random
from playwright.async_api import async_playwright

URLS = [
    "https://example.com/page/1",
    "https://example.com/page/2",
    "https://example.com/page/3",
]

async def scrape(url: str, page) -> list[str]:
    await page.goto(url, wait_until="domcontentloaded")
    # polite pause — be a good citizen
    await asyncio.sleep(random.uniform(2.0, 4.0))
    return await page.locator(".item").all_inner_texts()

async def main():
    async with async_playwright() as p:
        browser = await p.chromium.launch(headless=True)
        ctx = await browser.new_context(
            user_agent="DataBot/1.0 (+https://example.com/bot)"
        )
        page = await ctx.new_page()

        for url in URLS:
            items = await scrape(url, page)
            print(url, "→", len(items), "items")

        await browser.close()

asyncio.run(main())

# Playwright trace viewer — debugging gold
# 1. Record a trace during tests
#    (in pytest, use the --tracing on flag)

# pytest tests/ --tracing on

# 2. On failure, traces are saved as:
#    test-results//trace.zip

# 3. Open the trace viewer:
#    playwright show-trace test-results//trace.zip

# 4. You get a step-by-step replay:
#    - DOM snapshot at every step
#    - Network requests
#    - Console logs
#    - Screenshots

# In interviews, mention traces. It signals you debug
# test failures methodically — a rare and valued skill.

Daily Playwright routine (45-60 minutes):
20 min — Read one concept (e.g., auto-waits)
20 min — Code along on a real page
10 min — Write your own notes
5  min — Review yesterday

Consistency beats intensity.
30 days × 45 min = a usable, marketable skill.

Recommended practice resources:
- Playwright for Python — official docs
- A public "sandbox" site you can test
  (e.g., the-internet.herokuapp.com,
  saucedemo.com, playwright.dev demo pages)
- Pytest documentation (fixtures, markers)
- GitHub: search "playwright python examples"

Rule: pick ONE public sandbox site and build
one project on it. Depth beats breadth.