qa-skills 3.0.0

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

@@ -0,0 +1,144 @@
+# Playwright Configuration Guide
+
+Configuration for `playwright.config.ts` and related setup.
+
+## Basic Structure
+
+```typescript
+import { defineConfig, devices } from '@playwright/test';
+
+export default defineConfig({
+  testDir: './e2e',
+  fullyParallel: true,
+  forbidOnly: !!process.env.CI,
+  retries: process.env.CI ? 2 : 0,
+  workers: process.env.CI ? 1 : undefined,
+  reporter: 'html',
+  use: {
+    baseURL: 'http://localhost:3000',
+    trace: 'on-first-retry',
+    screenshot: 'only-on-failure',
+    video: 'retain-on-failure',
+  },
+  projects: [
+    { name: 'chromium', use: { ...devices['Desktop Chrome'] } },
+    { name: 'firefox', use: { ...devices['Desktop Firefox'] } },
+    { name: 'webkit', use: { ...devices['Desktop Safari'] } },
+  ],
+});
+```
+
+## Projects Matrix
+
+| Option | Description | Example |
+|--------|-------------|---------|
+| Multiple browsers | Run same tests on Chromium, Firefox, WebKit | `projects: [{ use: devices['Desktop Chrome'] }, ...]` |
+| Mobile emulation | iPhone, Pixel | `devices['iPhone 13']` |
+| Custom project | Named project with overrides | `{ name: 'auth', use: { storageState: 'auth.json' } }` |
+| Dependencies | Run project B after A | `{ name: 'setup', testMatch: /global-setup/ }, { name: 'e2e', dependencies: ['setup'] }` |
+
+```typescript
+projects: [
+  { name: 'setup', testMatch: /.*\.setup\.ts/ },
+  {
+    name: 'chromium',
+    use: { ...devices['Desktop Chrome'] },
+    dependencies: ['setup'],
+  },
+  {
+    name: 'mobile',
+    use: { ...devices['iPhone 13'] },
+    dependencies: ['setup'],
+  },
+],
+```
+
+## Reporter Options
+
+| Reporter | Output | Use Case |
+|----------|--------|----------|
+| `list` | Console | Default, readable |
+| `html` | HTML report | `npx playwright show-report` |
+| `json` | JSON file | CI integration |
+| `junit` | JUnit XML | Jenkins, Azure DevOps |
+| `github` | GitHub Actions annotations | CI |
+| Multiple | Array | `reporter: [['html'], ['junit', { outputFile: 'results.xml' }]]` |
+
+## Retry Strategies
+
+| Option | Description | Example |
+|--------|-------------|---------|
+| `retries` | Number of retries on failure | `retries: 2` |
+| `retries` in CI | Often 2 in CI, 0 locally | `retries: process.env.CI ? 2 : 0` |
+| Per-test | `test.describe.configure({ retries: 1 })` | For flaky tests only |
+
+## Test Directory
+
+| Option | Description | Example |
+|--------|-------------|---------|
+| `testDir` | Root for tests | `testDir: './e2e'` |
+| `testMatch` | Glob pattern | `testMatch: '**/*.spec.ts'` |
+| `testIgnore` | Exclude | `testIgnore: '**/node_modules/**'` |
+
+## Global Setup/Teardown
+
+| File | Purpose |
+|------|---------|
+| `global-setup.ts` | Run once before all tests (auth, DB seed) |
+| `global-teardown.ts` | Run once after all tests (cleanup) |
+
+```typescript
+// playwright.config.ts
+export default defineConfig({
+  globalSetup: require.resolve('./global-setup'),
+  globalTeardown: require.resolve('./global-teardown'),
+});
+```
+
+```typescript
+// global-setup.ts
+async function globalSetup() {
+  // Login and save auth state
+  const request = await request.newContext();
+  await request.post('/api/login', { data: { email, password } });
+  await request.storageState({ path: 'auth.json' });
+}
+```
+
+## Authentication State
+
+| Option | Description | Example |
+|--------|-------------|---------|
+| `storageState` | Reuse cookies/localStorage | `use: { storageState: 'auth.json' }` |
+| Per-project | Auth only for some projects | `projects: [{ name: 'authenticated', use: { storageState: 'auth.json' } }]` |
+| In test | `context.addCookies()` for dynamic auth | For test-specific auth |
+
+## Use Options
+
+| Option | Description | Values |
+|--------|-------------|--------|
+| `baseURL` | Prepend to relative URLs | `'http://localhost:3000'` |
+| `trace` | When to capture trace | `'on-first-retry'`, `'on'`, `'off'` |
+| `screenshot` | When to capture | `'on'`, `'off'`, `'only-on-failure'` |
+| `video` | When to record | `'on'`, `'off'`, `'retain-on-failure'`, `'on-first-retry'` |
+| `actionTimeout` | Default action timeout | `15000` |
+| `navigationTimeout` | Page load timeout | `30000` |
+| `expect` | Assertion timeout | `{ timeout: 5000 }` |
+
+## Component Testing Config
+
+For `@playwright/experimental-ct-react` (and ct-vue, ct-svelte):
+
+```typescript
+// playwright-ct.config.ts
+import { defineConfig } from '@playwright/experimental-ct-react';
+
+export default defineConfig({
+  testDir: './components',
+  use: {
+    ctViteConfig: {
+      // Vite config for component tests
+    },
+  },
+});
+```

package/skills/qa-playwright-ts-writer/references/patterns.md

@@ -0,0 +1,171 @@
+# Playwright Test Patterns
+
+Common patterns for E2E testing with Playwright TypeScript.
+
+## Navigation
+
+| Pattern | Example |
+|---------|---------|
+| Go to URL | `await page.goto('/login')` or `await page.goto(baseURL + '/login')` |
+| Go back | `await page.goBack()` |
+| Reload | `await page.reload()` |
+| Wait for navigation | `await page.waitForURL('**/dashboard')` |
+
+```typescript
+test('navigates to dashboard after login', async ({ page }) => {
+  await page.goto('/login');
+  await page.getByRole('textbox', { name: 'Email' }).fill('user@example.com');
+  await page.getByLabel('Password').fill('secret');
+  await page.getByRole('button', { name: 'Sign in' }).click();
+  await expect(page).toHaveURL(/.*dashboard/);
+});
+```
+
+## Forms
+
+| Pattern | Example |
+|---------|---------|
+| Fill text | `await page.getByLabel('Name').fill('John')` |
+| Fill by role | `await page.getByRole('textbox', { name: 'Email' }).fill('a@b.com')` |
+| Select dropdown | `await page.getByLabel('Country').selectOption('US')` |
+| Check checkbox | `await page.getByRole('checkbox', { name: 'Subscribe' }).check()` |
+| Radio | `await page.getByRole('radio', { name: 'Option A' }).check()` |
+| Submit | `await page.getByRole('button', { name: 'Submit' }).click()` |
+
+```typescript
+test('submits registration form', async ({ page }) => {
+  await page.goto('/register');
+  await page.getByLabel('Email').fill('new@example.com');
+  await page.getByLabel('Password').fill('SecurePass123');
+  await page.getByRole('checkbox', { name: 'Terms' }).check();
+  await page.getByRole('button', { name: 'Create account' }).click();
+  await expect(page.getByText('Welcome')).toBeVisible();
+});
+```
+
+## Authentication
+
+| Pattern | Example |
+|---------|---------|
+| Login before each test | Use global setup or beforeEach with storageState |
+| Reuse auth state | Save storageState in setup; reuse via project config |
+| API login | Call login API, save cookies to storageState file |
+
+```typescript
+// global-setup.ts
+async function globalSetup() {
+  const response = await request.post('/api/login', { data: { email, password } });
+  const cookies = await response.headers['set-cookie'];
+  await fs.writeFile('auth.json', JSON.stringify({ cookies }));
+}
+
+// playwright.config.ts
+use: { storageState: 'auth.json' }
+```
+
+See `references/config.md` for auth state configuration.
+
+## File Upload
+
+| Pattern | Example |
+|---------|---------|
+| Single file | `await page.getByLabel('Upload').setInputFiles('fixtures/doc.pdf')` |
+| Multiple files | `await page.getByLabel('Upload').setInputFiles(['a.pdf', 'b.pdf'])` |
+| Buffer | `await page.getByLabel('Upload').setInputFiles({ name: 'test.txt', mimeType: 'text/plain', buffer: Buffer.from('content') })` |
+
+```typescript
+test('uploads file', async ({ page }) => {
+  await page.goto('/upload');
+  await page.getByLabel('Choose file').setInputFiles(path.join(__dirname, 'fixtures/sample.pdf'));
+  await page.getByRole('button', { name: 'Upload' }).click();
+  await expect(page.getByText('Upload complete')).toBeVisible();
+});
+```
+
+## Drag and Drop
+
+| Pattern | Example |
+|---------|---------|
+| locator.dragTo | `await page.locator('.item').dragTo(page.locator('.dropzone'))` |
+| Manual (low-level) | `await page.dispatchEvent(source, 'dragstart'); await page.dispatchEvent(target, 'drop')` |
+
+```typescript
+test('drags item to list', async ({ page }) => {
+  await page.goto('/kanban');
+  await page.locator('[data-id="task-1"]').dragTo(page.locator('[data-column="done"]'));
+  await expect(page.locator('[data-column="done"]')).toContainText('Task 1');
+});
+```
+
+## Iframe Handling
+
+| Pattern | Example |
+|---------|---------|
+| Get frame | `const frame = page.frameLocator('iframe[name="embed"]')` |
+| Interact in frame | `await frame.getByRole('button').click()` |
+| Nested frame | `const inner = frame.frameLocator('iframe')` |
+
+```typescript
+test('interacts with iframe content', async ({ page }) => {
+  await page.goto('/embed');
+  const frame = page.frameLocator('iframe#widget');
+  await frame.getByRole('button', { name: 'Submit' }).click();
+  await expect(frame.getByText('Success')).toBeVisible();
+});
+```
+
+## Multi-Tab
+
+| Pattern | Example |
+|---------|---------|
+| Wait for popup | `const [popup] = await Promise.all([page.waitForEvent('popup'), page.getByRole('link').click()])` |
+| New tab | `const context = page.context(); const newPage = await context.newPage()` |
+| Switch | Use `popup` or `newPage` for subsequent actions |
+
+```typescript
+test('opens link in new tab', async ({ page }) => {
+  const [popup] = await Promise.all([
+    page.waitForEvent('popup'),
+    page.getByRole('link', { name: 'External' }).click()
+  ]);
+  await popup.waitForLoadState();
+  await expect(popup).toHaveURL(/external\.com/);
+});
+```
+
+## API Mocking with page.route
+
+| Pattern | Example |
+|---------|---------|
+| Mock response | `await page.route('**/api/users', route => route.fulfill({ status: 200, body: JSON.stringify([]) }))` |
+| Abort request | `await page.route('**/analytics', route => route.abort())` |
+| Modify request | `await page.route('**/api/**', route => route.continue({ headers: { ...route.request().headers(), 'X-Custom': '1' } }))` |
+| Unroute | `await page.unroute('**/api/users')` |
+
+```typescript
+test('shows empty state when API returns no data', async ({ page }) => {
+  await page.route('**/api/items', route => route.fulfill({
+    status: 200,
+    contentType: 'application/json',
+    body: JSON.stringify({ items: [] })
+  }));
+  await page.goto('/items');
+  await expect(page.getByText('No items found')).toBeVisible();
+});
+```
+
+## Visual Comparison
+
+| Pattern | Example |
+|---------|---------|
+| Screenshot | `await expect(page).toHaveScreenshot('home.png')` |
+| Element screenshot | `await expect(page.locator('.widget')).toHaveScreenshot('widget.png')` |
+| Update snapshots | Run with `--update-snapshots` |
+| Mask | `await expect(page).toHaveScreenshot({ mask: [page.locator('.dynamic')] })` |
+
+```typescript
+test('homepage matches snapshot', async ({ page }) => {
+  await page.goto('/');
+  await expect(page).toHaveScreenshot('homepage.png');
+});
+```

package/skills/qa-pytest-writer/SKILL.md

@@ -0,0 +1,145 @@
+---
+name: qa-pytest-writer
+description: Generate pytest unit and integration tests for Python with fixtures, parametrize, markers, conftest patterns, and plugin ecosystem support.
+output_dir: tests/unit
+---
+
+# QA Pytest Writer
+
+## Purpose
+
+Write pytest unit and integration tests from test case specifications. Transform structured test cases (from qa-testcase-from-docs, qa-manual-test-designer, or specs) into executable pytest code with fixtures, parametrization, markers, and conftest patterns.
+
+## Trigger Phrases
+
+- "Write pytest tests for [module/function]"
+- "Generate pytest unit tests from test cases"
+- "Create pytest integration tests"
+- "Add pytest tests with fixtures for [feature]"
+- "Pytest parametrized tests for [function]"
+- "Pytest tests with conftest fixtures"
+- "Pytest async tests for [API handler]"
+- "Pytest tests with mocking (monkeypatch/patch)"
+
+## Key Features
+
+| Feature | Description |
+| ------- | ----------- |
+| **Fixtures** | Scope: function, class, module, session; autouse, yield for teardown |
+| **@pytest.mark.parametrize** | Data-driven tests with multiple input/output sets |
+| **Markers** | skip, skipif, xfail, custom markers for categorization |
+| **conftest.py** | Shared fixtures across test modules/directories |
+| **Plugin ecosystem** | pytest-cov, pytest-xdist, pytest-asyncio, pytest-html, pytest-factoryboy |
+| **Assertion introspection** | Rich failure output; plain `assert` statements |
+
+## Workflow
+
+1. **Read test cases** — From specs, requirements, or manual test designs
+2. **Analyze Python code** — Inspect module under test: functions, classes, dependencies
+3. **Generate test files** — Produce `test_{module}.py` with test functions
+4. **Add fixtures/conftest** — Shared setup, teardown, parametrization
+5. **Run** — User runs `pytest` to execute tests
+
+## Context7 MCP
+
+Use **Context7 MCP** for current pytest documentation when:
+- Fixture scope or parametrize syntax is uncertain
+- Plugin APIs (pytest-asyncio, pytest-cov) need verification
+- Marker or configuration options require up-to-date reference
+
+## Key Patterns
+
+| Pattern | Usage |
+| ------- | ----- |
+| `test_` prefix | Test functions: `def test_something():` |
+| `assert` | Plain assertions; no special API needed |
+| Fixtures | `def fixture_name():` with scope, autouse, yield |
+| `@pytest.mark.parametrize` | Data-driven tests |
+| Markers | `@pytest.mark.skip`, `@pytest.mark.skipif`, `@pytest.mark.xfail` |
+| conftest.py | Shared fixtures in package/directory |
+| monkeypatch | Built-in for patching attributes/env |
+| tmp_path | Built-in temporary directory fixture |
+| unittest.mock | `patch`, `MagicMock` for mocking |
+
+## Mocking
+
+| Approach | Use Case |
+| -------- | -------- |
+| **unittest.mock.patch** | Patch modules, classes, functions |
+| **unittest.mock.MagicMock** | Create mock objects with configurable behavior |
+| **pytest-mock (mocker)** | `mocker` fixture wraps patch; cleaner syntax |
+| **monkeypatch** | Built-in; patch attributes, env vars, sys.path |
+
+## Configuration
+
+- **pytest.ini** — Legacy config (markers, addopts, testpaths)
+- **pyproject.toml** — Modern config under `[tool.pytest.ini_options]`
+- **conftest.py** — Fixtures, hooks, plugin config
+
+See `references/config.md` for configuration patterns.
+
+## Plugin Recommendations
+
+| Plugin | Purpose |
+| ------ | ------- |
+| pytest-cov | Code coverage reporting |
+| pytest-xdist | Parallel test execution |
+| pytest-asyncio | Async test support |
+| pytest-html | HTML test reports |
+| pytest-factoryboy | Factory fixtures for models |
+
+## File Naming
+
+- `test_{module}.py` — Preferred (e.g., `test_calculator.py`)
+- Place in `tests/` or colocated with source per project convention
+
+## Scope
+
+**Can do (autonomous):**
+- Generate pytest unit and integration tests from test case specs
+- Add fixtures (function/class/module/session scope), conftest.py
+- Use @pytest.mark.parametrize for data-driven tests
+- Apply markers (skip, skipif, xfail, custom)
+- Mock with patch, MagicMock, monkeypatch, pytest-mock
+- Configure pytest.ini / pyproject.toml
+- Call qa-diagram-generator for test flow diagrams if needed
+
+**Cannot do (requires confirmation):**
+- Change production code to satisfy tests
+- Add tests for requirements not in source documents
+- Override project-level pytest config without approval
+
+**Will not do (out of scope):**
+- Execute tests (user runs `pytest`)
+- Write Playwright/Selenium E2E tests (use qa-playwright-ts-writer or Python E2E skills)
+- Modify CI/CD pipelines
+
+## References
+
+- `references/patterns.md` — Fixtures, parametrize, conftest, async testing, mocking
+- `references/assertions.md` — Assertion patterns: comparison, exceptions, warnings, approximate
+- `references/config.md` — pyproject.toml, pytest.ini, conftest.py, markers, plugins
+- `references/best-practices.md` — Fixture scope, naming, organization, test isolation, coverage
+
+## Quality Checklist
+
+- [ ] Tests match test case steps and expected results
+- [ ] Fixtures are properly scoped (function vs session)
+- [ ] No hardcoded secrets or sensitive data
+- [ ] Assertions are specific (avoid only truthiness where value matters)
+- [ ] Teardown via yield in fixtures where resources need cleanup
+- [ ] File naming follows `test_{module}.py` convention
+- [ ] Parametrize used for data-driven cases; markers for categorization
+- [ ] Coverage targets considered if specified in requirements
+
+## Troubleshooting
+
+| Symptom | Likely Cause | Fix |
+| ------- | ------------ | --- |
+| Fixture not found | Scope or conftest location | Ensure conftest.py in same dir or parent; check fixture scope |
+| Parametrize id collision | Duplicate ids | Use `ids` parameter for unique test names |
+| Tests pass individually, fail together | Shared mutable state | Use function-scoped fixtures; avoid module/session for mutable data |
+| monkeypatch not persisting | Wrong target path | Patch where object is used (e.g., `mymodule.func` not `builtins.func`) |
+| Async tests fail | Missing pytest-asyncio | Add `@pytest.mark.asyncio`; install pytest-asyncio |
+| Coverage not collected | Plugin not configured | Add pytest-cov; run `pytest --cov=src` |
+| Import errors in tests | Path/sys.path | Add `conftest.py` with `sys.path` or use `pyproject.toml` pythonpath |

package/skills/qa-pytest-writer/references/assertions.md

@@ -0,0 +1,149 @@
+# Pytest Assertion Patterns
+
+Pytest uses Python's built-in `assert` statement. Failed assertions are rewritten for rich, readable output.
+
+## Basic Assertions
+
+```python
+assert x == 5
+assert x != 0
+assert x > 3
+assert x >= 3
+assert x < 10
+assert x <= 10
+assert x in [1, 2, 3]
+assert x not in []
+assert "hello" in s
+assert True
+assert not False
+```
+
+## Comparison Assertions
+
+```python
+# Equality
+assert result == expected
+assert result != unexpected
+
+# Identity
+assert x is None
+assert x is not None
+
+# Type
+assert isinstance(obj, MyClass)
+assert not isinstance(obj, str)
+```
+
+## Collection Assertions
+
+```python
+# Lists
+assert len(items) == 3
+assert item in items
+assert items == [1, 2, 3]
+assert items != []
+
+# Dicts
+assert "key" in d
+assert d["key"] == value
+assert d.get("missing") is None
+```
+
+## Exception Testing
+
+### pytest.raises
+
+```python
+import pytest
+
+def test_raises_exception():
+    with pytest.raises(ValueError):
+        raise ValueError("invalid")
+
+def test_raises_with_message():
+    with pytest.raises(ValueError, match="invalid"):
+        raise ValueError("invalid input")
+
+def test_raises_exception_info():
+    with pytest.raises(ValueError) as exc_info:
+        raise ValueError("error message")
+    assert "error" in str(exc_info.value)
+```
+
+### Exception Type and Message
+
+```python
+with pytest.raises(ValueError, match=r"expected pattern"):
+    failing_function()
+```
+
+## Warning Testing
+
+```python
+import pytest
+import warnings
+
+def test_warning():
+    with pytest.warns(UserWarning, match="deprecated"):
+        deprecated_function()
+
+def test_warning_count():
+    with pytest.warns(UserWarning) as record:
+        warn_twice()
+    assert len(record) == 2
+```
+
+## Approximate Comparisons
+
+For floating-point values, use `pytest.approx`:
+
+```python
+def test_float_approximate():
+    assert 0.1 + 0.2 == pytest.approx(0.3)
+
+def test_float_with_tolerance():
+    assert 3.14159 == pytest.approx(3.14, rel=1e-2)
+
+def test_sequence_approximate():
+    assert [1.0, 2.0] == pytest.approx([1.001, 2.002], rel=1e-2)
+```
+
+## Mock Assertions (unittest.mock)
+
+```python
+from unittest.mock import MagicMock
+
+def test_mock_called(mock_obj):
+    mock_obj.method()
+    mock_obj.method.assert_called_once()
+    mock_obj.method.assert_called_with(arg1, arg2)
+    mock_obj.method.assert_called_once_with(arg1, arg2)
+    assert mock_obj.method.call_count == 1
+```
+
+## Boolean and Truthiness
+
+```python
+assert result
+assert not empty_list
+assert bool(value) is True
+```
+
+## String Assertions
+
+```python
+assert "substring" in full_string
+assert full_string.startswith("prefix")
+assert full_string.endswith("suffix")
+assert "pattern" in full_string
+import re
+assert re.search(r"pattern", full_string)
+```
+
+## Best Practices
+
+1. **One logical assertion per test** — Easier to diagnose failures
+2. **Use descriptive variable names** — `expected_total` vs `x`
+3. **Prefer `pytest.approx` for floats** — Avoid direct `==` on floats
+4. **Use `pytest.raises` for exceptions** — Don't use try/except with assert
+5. **Assert on behavior, not implementation** — Test outcomes, not internals