qa-skills 3.0.0

package/skills/qa-plan-creator/templates/test-plan-template.md

@@ -0,0 +1,74 @@
+# Test Plan — {Project/Release Name}
+
+**Document ID:** {TP-XXX}
+**Version:** {1.0}
+**Date:** {YYYY-MM-DD}
+**Author:** {name}
+
+---
+
+## 1. Introduction
+
+### 1.1 Purpose
+{Purpose of this test plan and intended audience}
+
+### 1.2 Scope
+{In-scope and out-of-scope items}
+
+### 1.3 References
+- {Standard or document reference}
+- {Requirements document}
+- {Design specification}
+
+---
+
+## 2. Test Items
+{List of software items/features under test}
+
+## 3. Features to Test
+{Features and functionality included in test scope}
+
+## 4. Features NOT to Test
+{Explicitly excluded features with rationale}
+
+## 5. Test Approach
+{Test strategy, techniques, tools, and coverage approach}
+
+## 6. Entry Criteria
+- {Criterion 1}
+- {Criterion 2}
+
+## 7. Exit Criteria
+- {Criterion 1}
+- {Criterion 2}
+
+## 8. Test Environment
+{Environment description, hardware, software, test data}
+
+## 9. Schedule
+| Phase | Start | End | Deliverable |
+|-------|-------|-----|-------------|
+| {Phase 1} | {date} | {date} | {deliverable} |
+| {Phase 2} | {date} | {date} | {deliverable} |
+
+*Gantt: [Insert Gantt diagram placeholder]*
+
+## 10. Resources
+| Role | Name | Responsibility |
+|------|------|----------------|
+| {Role} | {Name} | {Responsibility} |
+
+## 11. Risks and Mitigations
+| Risk | Impact | Mitigation |
+|------|--------|------------|
+| {Risk} | {High/Med/Low} | {Mitigation} |
+
+## 12. Deliverables
+- {Test specifications}
+- {Test execution logs}
+- {Test completion report}
+
+## 13. Approval
+| Role | Name | Date | Signature |
+|------|------|------|-----------|
+| {Approver} | {Name} | {date} | |

package/skills/qa-playwright-py-writer/SKILL.md

@@ -0,0 +1,156 @@
+---
+name: qa-playwright-py-writer
+description: Generate Playwright E2E tests for Python with async/sync API, pytest-playwright integration, POM pattern, and live browser record mode via Playwright MCP.
+output_dir: tests/e2e
+---
+
+# QA Playwright Python Writer
+
+## Purpose
+
+Write Playwright E2E tests for Python from test case specifications. Transform structured test cases into executable Playwright Python test files with pytest-playwright, Page Object Model, auto-waiting, multi-browser support, and optional live browser record mode.
+
+## Trigger Phrases
+
+- "Write Playwright Python tests for [feature/flow]"
+- "Generate Playwright E2E tests in Python"
+- "Create pytest-playwright tests"
+- "Add Playwright tests with record mode (Python)"
+- "Playwright Python tests for [URL/flow]"
+- "POM-based Playwright tests in Python"
+- "pytest-playwright tests for [page]"
+- "Heal my failing Playwright Python tests"
+
+## Three Modes
+
+| Mode | When to Use | Behavior |
+|------|-------------|----------|
+| **Record Mode** | User wants live browser capture | Use Playwright MCP (e.g., cursor-ide-browser) → navigate, interact, capture interactions → generate Python test code from recorded steps |
+| **Generate Mode** | Default; from test case specs | Read test cases (from qa-testcase-from-docs, qa-testcase-from-ui, qa-manual-test-designer) → generate Playwright Python code |
+| **Heal Mode** | Tests fail after changes | Delegate to **qa-test-healer** to auto-fix broken selectors, assertions, waits; mark unfixable as `pytest.mark.skip` |
+
+## Key Features
+
+| Feature | Description |
+|---------|-------------|
+| **Sync/Async API** | Default sync API; async via `playwright_pytest_asyncio = True` in pytest config |
+| **pytest-playwright** | Fixtures: `page`, `browser`, `context`, `playwright`; integrates with pytest |
+| **POM pattern** | Base page classes, page-specific classes, component objects |
+| **Auto-wait** | Playwright auto-waits for elements; avoid `page.wait_for_timeout` |
+| **Multi-browser** | Chromium, Firefox, WebKit via pytest-playwright browser options |
+| **Network interception** | `page.route` for API mocking, request/response handling |
+
+## Workflow
+
+1. **Read test cases** — From specs, requirements, or manual test designs
+2. **Analyze app** — Inspect pages, flows, selectors (or use Record Mode)
+3. **Generate tests** — Produce `test_{feature}.py` with POM where appropriate
+4. **Configure** — Add/update `conftest.py`, `pytest.ini` or `pyproject.toml`
+5. **Run** — User runs `pytest` to execute tests
+
+## E2E Testing
+
+- **Navigation:** `page.goto()`, `page.go_back()`, `page.reload()`
+- **Interactions:** `click()`, `fill()`, `select_option()`, `check()`, `hover()`, `press()`
+- **Assertions:** `expect(locator).to_be_visible()`, `to_have_text()`, `to_have_url()`, etc.
+- **Network:** `page.route()` for API mocking, request/response interception
+- **Auto-wait:** Playwright auto-waits; avoid `page.wait_for_timeout()`
+
+See `references/patterns.md` for navigation, forms, auth, file upload, drag-drop, iframes, multi-tab, API mocking, visual comparison.
+
+## Page Object Model (POM)
+
+- **Base page:** Shared selectors, navigation helpers, common actions
+- **Page-specific:** Extend base; encapsulate page-specific locators and methods
+- **Component objects:** Reusable components (header, modal, form) as classes
+
+See `references/best-practices.md` for POM structure.
+
+## Key Patterns
+
+- **Structure:** `def test_*()` functions; `pytest.mark` for grouping; `conftest.py` for fixtures
+- **Locators:** `get_by_role` > `get_by_test_id` > `get_by_text` > `get_by_label` > CSS selector
+- **Assertions:** `expect(locator).to_be_visible()`, `to_have_text()`, `to_have_url()`, `to_have_count()`, etc.
+- **Network:** `page.route(url, handler)` for mocking; `page.unroute()` to clear
+- **Fixtures:** `page`, `browser`, `context`, `playwright` from pytest-playwright; custom fixtures in conftest.py
+
+See `references/patterns.md` for full pattern reference.
+
+## Locator Priority
+
+1. **get_by_role** — Accessibility-based; most resilient
+2. **get_by_test_id** — `data-testid`; explicit, stable
+3. **get_by_text** — Visible text; use for unique labels
+4. **get_by_label** — Form labels; good for inputs
+5. **CSS selector** — Last resort; brittle for dynamic content
+
+## File Naming
+
+- **Tests:** `test_{feature}.py` (e.g., `test_login.py`, `test_checkout.py`)
+- **Fixtures:** `conftest.py` in test directory or package root
+- **Page objects:** `pages/` or `page_objects/` directory
+
+## Configuration
+
+- **pytest.ini** / **pyproject.toml** — pytest options, markers, playwright settings
+- **conftest.py** — Shared fixtures, base URL, browser options
+- **pytest-playwright** — Provides `page`, `browser`, `context` fixtures
+
+See `references/config.md` for full config guide.
+
+## MCP Integration
+
+- **Context7 MCP** — Fetch Playwright Python documentation when needed
+- **Playwright MCP** (cursor-ide-browser, @playwright/mcp) — Record mode: navigate, snapshot, click, type; capture interactions → generate Python test code
+
+## Scope
+
+**Can do (autonomous):**
+- Generate Playwright E2E tests in Python from test case specs
+- Use Record Mode with Playwright MCP to capture and generate tests
+- Apply POM pattern, stable locators, auto-wait
+- Configure conftest.py, pytest.ini, pyproject.toml for pytest-playwright
+- Use `page.route()` for API mocking
+- Delegate to qa-test-healer when tests fail (Heal Mode)
+- Use Context7 MCP for Playwright Python docs
+
+**Cannot do (requires confirmation):**
+- Change production code structure
+- Add dependencies not in requirements.txt / pyproject.toml
+- Override project pytest/playwright config without approval
+- Navigate to URLs not provided (Record Mode)
+
+**Will not do (out of scope):**
+- Execute tests (user runs `pytest`)
+- Write pytest unit tests without Playwright (use qa-pytest-writer)
+- Modify CI/CD pipelines
+- Bypass security or access restricted areas
+
+## References
+
+- `references/patterns.md` — Sync vs async, pytest fixtures, POM, network mocking
+- `references/config.md` — pytest-playwright, conftest.py, pytest.ini, browser config
+- `references/best-practices.md` — POM, locators, async patterns, test isolation
+
+## Quality Checklist
+
+- [ ] Auto-wait used; no `page.wait_for_timeout` (use `expect` with timeout or `wait_for`)
+- [ ] No hardcoded waits; prefer `expect` auto-retry
+- [ ] POM pattern applied for page-specific logic
+- [ ] Stable locators (get_by_role, get_by_test_id preferred)
+- [ ] Tests independent (no shared state, order-independent)
+- [ ] Proper teardown (fixtures, conftest if needed)
+- [ ] Traceability to test case IDs where applicable
+- [ ] No hardcoded secrets (use env vars)
+
+## Troubleshooting
+
+| Symptom | Likely Cause | Fix |
+|---------|--------------|-----|
+| Element not found | Selector too specific, dynamic content | Use get_by_role/get_by_test_id; add data-testid if needed |
+| Timeout | Element not ready, slow network | Increase expect timeout; use wait_for; check for overlays |
+| Flaky tests | Race conditions, shared state | Ensure test isolation; use auto-wait; avoid fixed delays |
+| Record mode empty | MCP not capturing steps | Verify Playwright MCP active; lock browser before actions |
+| Sync/async conflict | Mixing sync and async fixtures | Use one mode per file; set playwright_pytest_asyncio consistently |
+| API mock not applied | Route registered after request | Call page.route before page.goto |
+| Fixture not found | conftest.py not in path | Ensure conftest.py in test directory or parent |

package/skills/qa-playwright-py-writer/references/best-practices.md

@@ -0,0 +1,194 @@
+# Playwright Python Best Practices
+
+Guidelines for maintainable, stable Playwright tests in Python.
+
+## Page Object Model (POM)
+
+### Structure
+
+```
+pages/
+  __init__.py
+  base_page.py      # Shared navigation, common helpers
+  login_page.py     # Login-specific locators and methods
+  dashboard_page.py # Dashboard-specific
+components/
+  __init__.py
+  header.py         # Reusable header component
+  modal.py          # Reusable modal
+```
+
+### Base Page
+
+```python
+# pages/base_page.py
+from playwright.sync_api import Page
+
+class BasePage:
+    def __init__(self, page: Page, base_url: str):
+        self.page = page
+        self.base_url = base_url
+
+    def goto(self, path: str):
+        self.page.goto(f"{self.base_url}{path}")
+
+    def get_by_test_id(self, test_id: str):
+        return self.page.get_by_test_id(test_id)
+```
+
+### Page-Specific Class
+
+```python
+# pages/login_page.py
+from playwright.sync_api import Page
+from .base_page import BasePage
+
+class LoginPage(BasePage):
+    def __init__(self, page: Page, base_url: str):
+        super().__init__(page, base_url)
+
+    def login(self, email: str, password: str):
+        self.page.get_by_label("Email").fill(email)
+        self.page.get_by_label("Password").fill(password)
+        self.page.get_by_role("button", name="Sign in").click()
+
+    @property
+    def error_message(self):
+        return self.page.get_by_role("alert")
+```
+
+### Usage in Tests
+
+```python
+# tests/e2e/test_login.py
+def test_login_flow(page: Page, base_url: str):
+    login_page = LoginPage(page, base_url)
+    login_page.goto("/login")
+    login_page.login("user@example.com", "secret")
+    expect(login_page.error_message).not_to_be_visible()
+```
+
+## Locator Priority
+
+1. **get_by_role** — Accessibility-based; most resilient
+2. **get_by_test_id** — `data-testid`; explicit, stable
+3. **get_by_text** — Visible text; use for unique labels
+4. **get_by_label** — Form labels; good for inputs
+5. **locator** / CSS — Last resort; brittle for dynamic content
+
+### Examples
+
+```python
+# Prefer
+page.get_by_role("button", name="Submit")
+page.get_by_test_id("submit-btn")
+page.get_by_label("Email address")
+page.get_by_text("Welcome back")
+
+# Avoid when possible
+page.locator(".btn-primary")
+page.locator("#submit")
+page.locator("div > span:nth-child(2)")
+```
+
+## Async Patterns
+
+When using async mode (`playwright_pytest_asyncio = True`):
+
+- Use `async def` for test functions
+- Use `await` for all Playwright calls
+- Do not mix sync and async in the same file
+- Use `@pytest.mark.asyncio` if not using `asyncio_mode = "auto"`
+
+```python
+@pytest.mark.asyncio
+async def test_async_login(page: Page):
+    await page.goto("/login")
+    await page.get_by_label("Email").fill("user@example.com")
+    await page.get_by_role("button", name="Sign in").click()
+    await expect(page).to_have_url(re.compile(r".*dashboard"))
+```
+
+## Test Isolation
+
+- Each test gets a fresh `page` and `context` (function scope)
+- No shared cookies, localStorage, or session between tests
+- Use `storage_state` for auth when needed (via project or fixture)
+- Clean up test data in `teardown` if tests create DB records
+
+## Avoiding Flakiness
+
+| Practice | Description |
+|----------|-------------|
+| **Auto-wait** | Playwright auto-waits; avoid `page.wait_for_timeout()` |
+| **Assert before act** | Use `expect` to wait for readiness before clicking |
+| **Stable selectors** | Prefer role/testid over CSS |
+| **Isolation** | Each test gets fresh context |
+| **Deterministic data** | Use fixtures, mocks; avoid time-dependent data |
+| **No fixed delays** | Use `expect` with timeout or `wait_for_*` instead |
+
+### Anti-Patterns
+
+```python
+# BAD: Fixed delay
+page.wait_for_timeout(3000)
+
+# GOOD: Wait for element
+expect(page.get_by_role("heading")).to_be_visible()
+
+# BAD: Brittle CSS
+page.locator("div.container > div:nth-child(2) button").click()
+
+# GOOD: Role or testid
+page.get_by_role("button", name="Save").click()
+```
+
+## File Naming
+
+| Convention | Example |
+|------------|---------|
+| Test files | `test_{feature}.py` (e.g., `test_login.py`, `test_dashboard.py`) |
+| Page objects | `{page_name}_page.py` (e.g., `login_page.py`) |
+| Fixtures | `conftest.py` (pytest discovers automatically) |
+
+## Debugging
+
+| Tool | Use |
+|------|-----|
+| `--headed` | Run with visible browser |
+| `--slowmo 1000` | Slow down actions (ms) |
+| `page.pause()` | Breakpoint; opens Playwright Inspector |
+| `PWDEBUG=1 pytest` | Run in debug mode |
+| `--screenshot=on-failure` | Capture screenshot on failure (via plugin options) |
+
+## Fixtures for Common Setup
+
+```python
+# conftest.py
+@pytest.fixture
+def login_page(page: Page, base_url: str):
+    from pages.login_page import LoginPage
+    return LoginPage(page, base_url)
+
+@pytest.fixture
+def logged_in_user(page: Page, base_url: str):
+    """Navigate to app and log in; return page."""
+    page.goto(f"{base_url}/login")
+    page.get_by_label("Email").fill("test@example.com")
+    page.get_by_label("Password").fill("secret")
+    page.get_by_role("button", name="Sign in").click()
+    page.wait_for_url(re.compile(r".*dashboard"))
+    return page
+```
+
+## Traceability
+
+Link tests to test case IDs when applicable:
+
+```python
+@pytest.mark.tc_id("TC-001")
+def test_login_with_valid_credentials(page: Page):
+    ...
+```
+
+Use markers or docstrings for traceability to requirements/specs.

package/skills/qa-playwright-py-writer/references/config.md

@@ -0,0 +1,195 @@
+# Playwright Python Configuration
+
+Setup for pytest-playwright and Playwright Python.
+
+## Installation
+
+```bash
+pip install pytest-playwright
+playwright install
+```
+
+Optional: install only specific browsers:
+
+```bash
+playwright install chromium
+playwright install chromium firefox webkit
+```
+
+## pytest-playwright Plugin
+
+The plugin provides fixtures automatically when installed. No explicit registration needed.
+
+| Fixture | Description |
+|---------|-------------|
+| `playwright` | Playwright instance (session scope) |
+| `browser_type` | Browser type launcher |
+| `browser` | Browser instance |
+| `context` | Browser context |
+| `page` | Page (tab) |
+
+## conftest.py
+
+Use `conftest.py` for shared fixtures and Playwright configuration.
+
+```python
+# conftest.py
+import pytest
+from playwright.sync_api import Page
+
+@pytest.fixture(scope="session")
+def base_url():
+    return "http://localhost:3000"
+
+@pytest.fixture
+def authenticated_page(page: Page, base_url: str):
+    """Page with pre-authenticated session."""
+    page.goto(f"{base_url}/login")
+    page.get_by_label("Email").fill("test@example.com")
+    page.get_by_label("Password").fill("secret")
+    page.get_by_role("button", name="Sign in").click()
+    page.wait_for_url(re.compile(r".*dashboard"))
+    return page
+```
+
+## pytest.ini / pyproject.toml
+
+### Basic pytest.ini
+
+```ini
+[pytest]
+testpaths = tests
+addopts = -v --tb=short
+markers =
+    e2e: end-to-end browser tests
+    slow: slow tests
+```
+
+### pyproject.toml (Preferred)
+
+```toml
+[tool.pytest.ini_options]
+testpaths = ["tests", "e2e"]
+addopts = "-v --tb=short"
+markers = [
+    "e2e: end-to-end browser tests",
+    "slow: marks tests as slow",
+]
+```
+
+### Async Mode (Optional)
+
+To use async Playwright API with pytest-playwright:
+
+```ini
+# pytest.ini
+[pytest]
+playwright_pytest_asyncio = True
+```
+
+Or in pyproject.toml:
+
+```toml
+[tool.pytest.ini_options]
+playwright_pytest_asyncio = true
+```
+
+Note: Sync and async fixtures cannot be mixed in the same test file.
+
+## Browser Configuration
+
+### Run Specific Browsers
+
+```bash
+pytest --browser chromium
+pytest --browser firefox
+pytest --browser webkit
+pytest --browser chromium --browser firefox
+```
+
+### Headed Mode (Visible Browser)
+
+```bash
+pytest --headed
+```
+
+### Slow Motion
+
+```bash
+pytest --slowmo 1000
+```
+
+### Video / Screenshot
+
+Configure via `browser_context_args` fixture:
+
+```python
+# conftest.py
+@pytest.fixture(scope="session")
+def browser_context_args(browser_context_args):
+    return {
+        **browser_context_args,
+        "record_video_dir": "videos/",
+        "record_video_size": {"width": 1280, "height": 720},
+    }
+```
+
+## Base URL
+
+```python
+# conftest.py
+@pytest.fixture(scope="session")
+def base_url():
+    import os
+    return os.environ.get("BASE_URL", "http://localhost:3000")
+
+# In tests
+def test_homepage(page: Page, base_url: str):
+    page.goto(base_url)
+```
+
+## Environment Variables
+
+| Variable | Description |
+|----------|-------------|
+| `BASE_URL` | Application under test |
+| `HEADED` | Set to `1` for visible browser |
+| `SLOWMO` | Milliseconds delay between actions |
+| `BROWSER` | `chromium`, `firefox`, or `webkit` |
+
+## Project Structure
+
+```
+project/
+├── conftest.py           # Shared fixtures
+├── pytest.ini            # or pyproject.toml
+├── tests/
+│   ├── e2e/
+│   │   ├── test_login.py
+│   │   ├── test_dashboard.py
+│   │   └── conftest.py   # E2E-specific fixtures
+│   └── ...
+├── pages/                # Page Object Model
+│   ├── base_page.py
+│   ├── login_page.py
+│   └── dashboard_page.py
+└── fixtures/             # Test data, upload files
+    └── sample.pdf
+```
+
+## Playwright Config (Optional)
+
+For advanced configuration, create `playwright.config.py`:
+
+```python
+# playwright.config.py
+from playwright.sync_api import sync_playwright
+
+def get_browser_context_args():
+    return {
+        "viewport": {"width": 1280, "height": 720},
+        "ignore_https_errors": True,
+    }
+```
+
+pytest-playwright uses its own defaults; override via `browser_context_args` fixture in conftest.py.