qa-skills 3.0.0

package/skills/qa-pytest-writer/references/best-practices.md

@@ -0,0 +1,97 @@
+# Pytest Best Practices
+
+## Fixture Scope
+
+| Scope | When to Use |
+| ----- | ----------- |
+| `function` | Default; mutable data, per-test isolation |
+| `class` | Shared setup for a group of related tests |
+| `module` | Expensive setup (DB, server) used by many tests |
+| `session` | Global resources (config, connections) for entire run |
+
+**Avoid:** Session/module scope for mutable state that tests modify. Prefer function scope for isolation.
+
+## Naming Conventions
+
+- **Test files:** `test_{module}.py` (e.g., `test_calculator.py`)
+- **Test functions:** `test_{behavior}` (e.g., `test_add_returns_sum`)
+- **Test classes:** `Test{Feature}` (e.g., `TestCalculator`)
+- **Fixtures:** Descriptive names (e.g., `sample_user`, `db_connection`)
+
+## Test Organization
+
+1. **One assert focus per test** — Easier to pinpoint failures
+2. **Arrange-Act-Assert** — Setup, execute, verify
+3. **Descriptive names** — `test_returns_404_when_user_not_found` not `test_api`
+4. **Group related tests** — Use classes or modules
+
+## Test Isolation
+
+- Each test should be independent; order should not matter
+- Use `function`-scoped fixtures for mutable data
+- Reset mocks in fixtures or `autouse` teardown
+- Avoid global state; prefer dependency injection via fixtures
+
+## Parametrize vs Multiple Tests
+
+Use `@pytest.mark.parametrize` when:
+- Same logic, different inputs/outputs
+- Boundary values, edge cases
+- Table-driven scenarios
+
+Use separate tests when:
+- Different setup or behavior
+- Different assertions or error paths
+
+## Mocking Best Practices
+
+1. **Patch where used** — `patch("mymodule.api.call")` not `patch("api.call")`
+2. **Prefer pytest-mock** — Cleaner lifecycle; auto-restore
+3. **Mock at boundaries** — External APIs, DB, file I/O
+4. **Avoid over-mocking** — Test real behavior when practical
+
+## Coverage
+
+- Use `pytest-cov` for coverage reports
+- Aim for meaningful coverage; 100% is not always practical
+- Focus on critical paths, error handling, edge cases
+- Run `pytest --cov --cov-report=html` for detailed reports
+
+## Async Tests
+
+- Use `pytest-asyncio` with `asyncio_mode = "auto"`
+- Mark async tests: `@pytest.mark.asyncio`
+- Avoid mixing sync and async in same test file without care
+
+## Conftest Hierarchy
+
+```
+project/
+  conftest.py           # Project-wide fixtures
+  tests/
+    conftest.py         # Test package fixtures
+    unit/
+      conftest.py       # Unit-test-specific
+    integration/
+      conftest.py       # Integration-specific (DB, API)
+```
+
+Place fixtures at the lowest level that needs them.
+
+## Performance
+
+- Use `-n auto` (pytest-xdist) for parallel runs
+- Mark slow tests: `@pytest.mark.slow`; exclude with `-m "not slow"`
+- Use module/session fixtures for expensive setup when safe
+- Mock external calls to avoid network/DB latency
+
+## Anti-Patterns to Avoid
+
+| Anti-Pattern | Better Approach |
+| ------------ | --------------- |
+| Shared mutable state across tests | Function-scoped fixtures |
+| Asserting implementation details | Assert outcomes and behavior |
+| One giant test with many asserts | Split into focused tests |
+| Hardcoded test data in production paths | Use fixtures, env vars |
+| Skipping tests without reason | Fix or xfail with ticket reference |
+| Patch at definition site | Patch at use site |

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

@@ -0,0 +1,176 @@
+# Pytest Configuration
+
+## pyproject.toml (Preferred)
+
+Modern Python projects use `pyproject.toml`:
+
+```toml
+[tool.pytest.ini_options]
+minversion = "7.0"
+testpaths = ["tests"]
+pythonpath = ["."]
+addopts = "-v --tb=short"
+asyncio_mode = "auto"
+filterwarnings = [
+    "ignore::DeprecationWarning",
+    "ignore::UserWarning",
+]
+markers = [
+    "slow: marks tests as slow (deselect with '-m \"not slow\"')",
+    "integration: marks integration tests",
+]
+```
+
+## pytest.ini (Legacy)
+
+```ini
+[pytest]
+minversion = 7.0
+testpaths = tests
+pythonpath = .
+addopts = -v --tb=short
+markers =
+    slow: marks tests as slow
+    integration: marks integration tests
+filterwarnings =
+    ignore::DeprecationWarning
+```
+
+## conftest.py
+
+Use for fixtures, hooks, and plugin-like behavior. No pytest.ini options here; use for code.
+
+```python
+# conftest.py
+import pytest
+
+def pytest_configure(config):
+    config.addinivalue_line("markers", "slow: marks tests as slow")
+
+@pytest.fixture(scope="session")
+def app():
+    from myapp import create_app
+    return create_app()
+```
+
+## Key Options
+
+| Option | Description |
+| ------ | ----------- |
+| `testpaths` | Directories to search for tests |
+| `pythonpath` | Paths to add to PYTHONPATH |
+| `addopts` | Default command-line options |
+| `minversion` | Minimum pytest version |
+| `asyncio_mode` | `auto` or `strict` for pytest-asyncio |
+| `filterwarnings` | Suppress or promote warnings |
+| `markers` | Register custom markers |
+
+## Markers
+
+### Registering Markers
+
+In pyproject.toml:
+
+```toml
+[tool.pytest.ini_options]
+markers = [
+    "slow: marks tests as slow",
+    "integration: marks integration tests",
+    "unit: marks unit tests",
+]
+```
+
+### Using Markers
+
+```python
+@pytest.mark.slow
+def test_heavy():
+    pass
+
+@pytest.mark.integration
+def test_api():
+    pass
+```
+
+### Running by Marker
+
+```bash
+pytest -m "not slow"
+pytest -m integration
+pytest -m "slow and integration"
+```
+
+## Plugins
+
+### pytest-cov (Coverage)
+
+```bash
+pip install pytest-cov
+pytest --cov=src --cov-report=html
+```
+
+In config:
+
+```toml
+[tool.pytest.ini_options]
+addopts = "--cov=src --cov-report=term-missing"
+```
+
+### pytest-xdist (Parallel)
+
+```bash
+pip install pytest-xdist
+pytest -n auto
+```
+
+### pytest-asyncio
+
+```bash
+pip install pytest-asyncio
+```
+
+```toml
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+```
+
+### pytest-html (Reports)
+
+```bash
+pip install pytest-html
+pytest --html=report.html
+```
+
+### pytest-factoryboy
+
+```bash
+pip install pytest-factoryboy
+```
+
+Integrates Factory Boy with pytest fixtures for test data factories.
+
+## Hooks (conftest.py)
+
+```python
+def pytest_collection_modifyitems(config, items):
+    """Add markers based on path."""
+    for item in items:
+        if "integration" in str(item.fspath):
+            item.add_marker(pytest.mark.integration)
+
+def pytest_configure(config):
+    """Register markers."""
+    config.addinivalue_line("markers", "slow: slow tests")
+```
+
+## Environment Variables
+
+Set in conftest.py or shell:
+
+```python
+# conftest.py
+import os
+os.environ["TESTING"] = "1"
+```
+
+Or use `pytest-env` plugin or `.env` with `python-dotenv`.

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

@@ -0,0 +1,251 @@
+# Pytest Patterns
+
+## Fixtures
+
+### Basic Fixture
+
+```python
+import pytest
+
+@pytest.fixture
+def sample_data():
+    return {"key": "value"}
+
+def test_with_fixture(sample_data):
+    assert sample_data["key"] == "value"
+```
+
+### Fixture Scopes
+
+| Scope | Lifecycle |
+| ----- | --------- |
+| `function` | Default; one per test |
+| `class` | One per test class |
+| `module` | One per test module |
+| `session` | One per test session |
+
+```python
+@pytest.fixture(scope="module")
+def shared_resource():
+    resource = create_resource()
+    yield resource
+    resource.cleanup()
+```
+
+### autouse Fixtures
+
+Run automatically without being requested as a parameter:
+
+```python
+@pytest.fixture(autouse=True)
+def reset_state():
+    # Setup
+    yield
+    # Teardown
+```
+
+### Fixture with Teardown (yield)
+
+```python
+@pytest.fixture
+def db_connection():
+    conn = connect_to_db()
+    yield conn
+    conn.close()
+```
+
+### Fixture Composition
+
+Fixtures can depend on other fixtures:
+
+```python
+@pytest.fixture
+def base_url():
+    return "https://api.example.com"
+
+@pytest.fixture
+def api_client(base_url):
+    return ApiClient(base_url)
+```
+
+## Parametrize
+
+### Basic Parametrize
+
+```python
+@pytest.mark.parametrize("a,b,expected", [
+    (1, 2, 3),
+    (0, 0, 0),
+    (-1, 1, 0),
+])
+def test_add(a, b, expected):
+    assert a + b == expected
+```
+
+### Parametrize with IDs
+
+```python
+@pytest.mark.parametrize("input,expected", [
+    ("hello", "HELLO"),
+    ("world", "WORLD"),
+], ids=["uppercase_hello", "uppercase_world"])
+def test_uppercase(input, expected):
+    assert input.upper() == expected
+```
+
+### Parametrize with Fixtures
+
+```python
+@pytest.fixture
+def calculator():
+    return Calculator()
+
+@pytest.mark.parametrize("a,b,expected", [(1, 2, 3), (4, 5, 9)])
+def test_add(calculator, a, b, expected):
+    assert calculator.add(a, b) == expected
+```
+
+## conftest.py
+
+Shared fixtures and configuration. Place in test directory or package:
+
+```
+tests/
+  conftest.py          # Shared by all tests in tests/
+  unit/
+    conftest.py        # Shared by unit tests only
+    test_foo.py
+  integration/
+    conftest.py
+    test_api.py
+```
+
+```python
+# tests/conftest.py
+import pytest
+
+@pytest.fixture
+def app_config():
+    return {"env": "test", "debug": True}
+```
+
+## Markers
+
+### Built-in Markers
+
+```python
+@pytest.mark.skip(reason="Not implemented yet")
+def test_future_feature():
+    pass
+
+@pytest.mark.skipif(sys.platform == "win32", reason="Unix only")
+def test_unix_only():
+    pass
+
+@pytest.mark.xfail(reason="Known bug #123")
+def test_known_bug():
+    assert False
+```
+
+### Custom Markers
+
+Register in pytest.ini or pyproject.toml:
+
+```ini
+[pytest]
+markers =
+    slow: marks tests as slow
+    integration: marks integration tests
+```
+
+```python
+@pytest.mark.slow
+def test_heavy_computation():
+    pass
+
+@pytest.mark.integration
+def test_api_endpoint():
+    pass
+```
+
+## Async Testing (pytest-asyncio)
+
+```python
+import pytest
+
+@pytest.mark.asyncio
+async def test_async_function():
+    result = await async_operation()
+    assert result == expected
+```
+
+Configure in pyproject.toml:
+
+```toml
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+```
+
+## Mocking
+
+### unittest.mock (patch)
+
+```python
+from unittest.mock import patch, MagicMock
+
+@patch("mymodule.external_api")
+def test_with_mock(mock_api):
+    mock_api.return_value = {"status": "ok"}
+    result = mymodule.fetch_data()
+    assert result["status"] == "ok"
+    mock_api.assert_called_once()
+```
+
+### pytest-mock (mocker fixture)
+
+```python
+def test_with_mocker(mocker):
+    mock_api = mocker.patch("mymodule.external_api", return_value={"status": "ok"})
+    result = mymodule.fetch_data()
+    assert result["status"] == "ok"
+    mock_api.assert_called_once()
+```
+
+### monkeypatch
+
+```python
+def test_env_var(monkeypatch):
+    monkeypatch.setenv("API_KEY", "test-key")
+    assert os.environ["API_KEY"] == "test-key"
+    # Automatically restored after test
+```
+
+## tmp_path
+
+Built-in fixture for temporary directories:
+
+```python
+def test_write_file(tmp_path):
+    file_path = tmp_path / "output.txt"
+    file_path.write_text("hello")
+    assert file_path.read_text() == "hello"
+```
+
+## Test Organization
+
+### Test Classes
+
+```python
+class TestCalculator:
+    def test_add(self):
+        assert 1 + 2 == 3
+
+    def test_subtract(self):
+        assert 5 - 3 == 2
+```
+
+### Naming Convention
+
+- Test files: `test_*.py` or `*_test.py`
+- Test functions: `test_*`
+- Test classes: `Test*` (optional)

package/skills/qa-qase-integration/SKILL.md

@@ -0,0 +1,149 @@
+---
+name: qa-qase-integration
+description: Qase.io TMS integration for syncing test cases, pushing test run results, and pulling test case updates between local QA workflow and Qase.io projects via REST API.
+dependencies:
+  recommended:
+    - qa-testcase-from-docs
+    - qa-test-reporter
+---
+
+# QA Qase Integration
+
+## Purpose
+
+Integrate the QA Skills ecosystem with Qase.io Test Management System. Sync test cases from Phase 2 outputs to Qase.io projects, push test execution results from CI/CD (JUnit XML → Qase runs), and pull test case updates back into local markdown/JSON for bidirectional traceability.
+
+## Features
+
+| Feature | Description |
+| ------- | ----------- |
+| **Sync test cases** | Push Phase 2 test case outputs (from qa-testcase-from-docs, qa-testcase-from-ui) to Qase.io projects |
+| **Push test results** | Map JUnit XML (and similar) to Qase test runs; create runs and post results |
+| **Pull updates** | Fetch test case changes from Qase.io into local markdown/JSON |
+| **Manage suites** | Create/update test suites and organize cases |
+| **Manage runs** | Create test runs, post results, track execution status |
+| **Manage defects** | Create defects from failed results; link to test cases |
+
+## API Configuration
+
+| Setting | Value |
+| ------- | ----- |
+| **Base URL** | `https://api.qase.io/v1` |
+| **Authentication** | `Token: {QASE_API_TOKEN}` header |
+| **Token source** | `.env` file — never hardcode |
+| **Rate limits** | 1,000 req/min per user; 3,000 req/min per IP |
+
+See `references/api-reference.md` for full endpoint details.
+
+## Key Endpoints
+
+| Resource | Method | Path |
+| -------- | ------ | ---- |
+| Projects | GET, POST | `/project` |
+| Test Suites | GET, POST | `/suite/{code}` |
+| Test Cases | GET, POST, PATCH | `/case/{code}` |
+| Test Runs | GET, POST | `/run/{code}` |
+| Test Results | POST | `/result/{code}/{run_id}` |
+| Defects | GET, POST | `/defect/{code}` |
+
+`{code}` = project code (2–10 chars).
+
+## Workflow
+
+```
+Generate test cases (Phase 2) → Sync to Qase.io → Run tests → Push results → Track defects
+```
+
+1. **Generate** — Use qa-testcase-from-docs, qa-testcase-from-ui, or qa-manual-test-designer to produce test cases.
+2. **Sync** — Map local format to Qase.io fields; create/update suites and cases.
+3. **Run** — Execute tests in CI/CD (Jest, pytest, Playwright, etc.).
+4. **Push** — Parse JUnit XML (or qase-api reporter output); create run; post results.
+5. **Track** — Create defects from failures; link to cases and runs.
+
+See `references/field-mapping.md` for local → Qase field mapping.
+
+## Field Mapping Summary
+
+| Local Field | Qase.io Field |
+| ----------- | ------------- |
+| title | title |
+| description | description |
+| preconditions | preconditions |
+| steps (Action \| Expected) | steps[].action, steps[].expected_result |
+| priority | priority (enum) |
+| severity | severity (enum) |
+| type | type (enum) |
+| automation status | automation (enum) |
+
+Full mapping and enums in `references/field-mapping.md`.
+
+## Integrations
+
+| Skill | Use |
+| ----- | --- |
+| **qa-testcase-from-docs** | Source of test cases to sync |
+| **qa-testcase-from-ui** | Source of test cases to sync |
+| **qa-manual-test-designer** | Source of manual test cases |
+| **qa-test-reporter** | JUnit XML parsing, report aggregation |
+| **qa-bug-ticket-creator** | Defect creation patterns; optionally link Qase defects to GitHub |
+| **qa-orchestrator** | Pipeline coordination (docs → cases → sync → run → report) |
+
+## Trigger Phrases
+
+- "Sync test cases to Qase.io"
+- "Push JUnit results to Qase"
+- "Create Qase run from test output"
+- "Pull test cases from Qase.io"
+- "Map local test cases to Qase format"
+- "Create defect in Qase from failed test"
+
+## Scope
+
+**Can do (autonomous):**
+- Sync test cases from local markdown/JSON to Qase.io
+- Create/update test suites and test cases
+- Create test runs and post results from JUnit XML
+- Map local format to Qase fields per `references/field-mapping.md`
+- Create defects from failed results
+- Pull test case updates into local format
+
+**Cannot do (requires confirmation):**
+- Modify Qase.io project settings (roles, custom fields, integrations)
+- Bulk delete test cases or suites
+- Change project code or workspace
+
+**Will not do (out of scope):**
+- Delete Qase.io projects
+- Modify billing or subscription
+- Access Qase.io UI or perform manual actions
+
+## Quality Checklist
+
+Before syncing or pushing:
+
+- [ ] `QASE_API_TOKEN` present in `.env`; never in code
+- [ ] Project code valid (2–10 chars, matches target project)
+- [ ] Local test case format matches mapping in `references/field-mapping.md`
+- [ ] JUnit XML (or equivalent) parseable; test names mappable to Qase cases
+- [ ] Rate limits considered for bulk operations (batch if needed)
+- [ ] Idempotency: check for existing case/run before create where appropriate
+
+## Troubleshooting
+
+| Symptom | Likely Cause | Fix |
+| ------- | ------------ | --- |
+| 401 Unauthorized | Missing or invalid token | Verify `QASE_API_TOKEN` in `.env`; check token at app.qase.io/user/api/token |
+| 403 Forbidden | Insufficient permissions | Verify role has required access; see Qase RBAC docs |
+| 404 Not Found | Invalid project code or ID | Confirm project code (2–10 chars); verify run/case/suite IDs exist |
+| 422 Unprocessable | Invalid field values | Check `references/field-mapping.md` for valid enums; validate request body |
+| 429 Too Many Requests | Rate limit exceeded | Implement backoff; batch requests; respect Retry-After header |
+| Case not found when pushing results | Case ID mismatch | Map JUnit test name to Qase case_id; use case title matching or external IDs |
+| Duplicate cases on sync | No deduplication | Match by title+suite or custom ID; update existing instead of create |
+
+## References
+
+| Topic | File |
+| ----- | ---- |
+| API endpoints, request/response examples | `references/api-reference.md` |
+| Local ↔ Qase field mapping, enums | `references/field-mapping.md` |
+| CI/CD integration (GitHub Actions, qase-api) | `references/ci-integration.md` |