qa-skills 3.0.0

package/skills/qa-coverage-analyzer/references/coverage-dimensions.md

@@ -0,0 +1,155 @@
+# Coverage Dimensions Reference
+
+Detailed reference for each coverage dimension with measurement methods per ISO/IEC/IEEE 29119 and industry practice.
+
+---
+
+## 1. Requirements/Model Coverage (RTM)
+
+### Definition
+
+Tracks which requirements have associated test models and test cases, and whether those tests have been executed. Ensures every requirement is verifiable.
+
+### RTM Structure
+
+```
+Requirement ID → Test Model → Test Case(s) → Execution Status
+```
+
+| Req ID | Test Model | Test Case(s) | Execution |
+|--------|------------|--------------|-----------|
+| REQ-001 | EP: email validation | TC-001, TC-002 | Pass |
+| REQ-002 | State: login flow | TC-003..006 | Pass |
+| REQ-003 | — | — | **Uncovered** |
+
+### Measurement Method
+
+1. **List all requirements** with unique IDs (from qa-requirements-generator or spec)
+2. **Map each requirement** to test model(s) and test case(s)
+3. **Compute coverage:** `Covered requirements / Total requirements × 100%`
+4. **Identify gaps:** Requirements with no test case or no execution
+
+### Gap Types
+
+| Gap Type | Description | Priority |
+|----------|-------------|----------|
+| No test case | Requirement has no linked test | High |
+| No execution | Test exists but not run | Medium |
+| Stale link | Test case outdated or removed | Medium |
+
+### Tools
+
+- Spreadsheets, RTM templates
+- Test management (Zephyr, TestRail, qTest) with traceability
+- qa-testcase-from-docs for RTM generation
+
+---
+
+## 2. Technique Coverage (ISO 29119-4)
+
+### Definition
+
+Ensures multiple test design techniques are applied across the system. Single-technique testing (e.g., only equivalence partitioning) may miss defects that other techniques would catch.
+
+### ISO 29119-4 Techniques
+
+| Technique | Abbreviation | When to Use |
+|-----------|--------------|-------------|
+| Equivalence Partitioning | EP | Input domains, validation |
+| Boundary Value Analysis | BVA | Numeric ranges, limits |
+| Decision Table | DT | Business rules, conditions |
+| State Transition | ST | Workflows, lifecycles |
+| Use Case | UC | User flows, scenarios |
+| Classification Tree | CT | Combinatorial, configs |
+
+### Measurement Method
+
+1. **Tag each test case** with technique(s) used (EP, BVA, DT, ST, UC, CT)
+2. **Per requirement or module:** Count distinct techniques applied
+3. **Compute coverage:** `Requirements with ≥2 techniques / Total × 100%` (or project-defined threshold)
+4. **Identify gaps:** Modules with only one technique or none
+
+### Technique Matrix Example
+
+| Module | EP | BVA | DT | ST | UC | Techniques Used |
+|--------|----|----|----|----|----|-----------------|
+| auth | ✓ | ✓ | ✓ | — | ✓ | 4 |
+| checkout | ✓ | — | — | — | — | 1 (gap) |
+| search | ✓ | ✓ | ✓ | — | ✓ | 4 |
+
+### Gap Types
+
+| Gap Type | Description | Priority |
+|----------|-------------|----------|
+| No technique | Test not tagged | Medium |
+| Single technique | Only EP or only BVA | Medium |
+| Missing for domain | BVA missing for numeric fields | High |
+
+### Reference
+
+- qa-testcase-from-docs `references/test-design-techniques.md`
+
+---
+
+## 3. Code Coverage
+
+### Definition
+
+Measures which lines, branches, conditions, and functions of the source code are executed by tests. Complements requirements and technique coverage by revealing untested implementation.
+
+### Coverage Types
+
+| Type | Description | Typical Target |
+|------|-------------|----------------|
+| **Line** | % of executable lines run | 70–80% |
+| **Branch** | % of decision branches (if/else) taken | 60–80% |
+| **Condition** | % of compound conditions (a && b) fully exercised | 50–70% |
+| **Function** | % of functions called | 80–90% |
+
+### Measurement Method
+
+1. **Instrument code** and run tests (see `references/tools.md`)
+2. **Parse coverage report** (Istanbul, JaCoCo, coverage.py, SonarQube)
+3. **Aggregate by module/package** for heatmap
+4. **Identify gaps:** Files or modules below threshold; 0% coverage areas
+
+### Tool Mapping by Language
+
+| Language | Primary Tool | Report Format |
+|----------|--------------|---------------|
+| JavaScript/TypeScript | Istanbul (c8, nyc), V8 | JSON, LCOV, HTML |
+| Java | JaCoCo | XML, HTML, CSV |
+| Python | coverage.py | XML, HTML, JSON |
+| .NET | Coverlet, OpenCover | XML, Cobertura |
+| Multi-language | SonarQube | Sonar format |
+
+### Gap Types
+
+| Gap Type | Description | Priority |
+|----------|-------------|----------|
+| 0% coverage | Entire file/module untested | High (if critical) |
+| Below threshold | Line coverage < project target | Medium |
+| Branch gap | Condition not fully exercised | Medium |
+
+---
+
+## Cross-Dimension Analysis
+
+Combine dimensions for richer insights:
+
+| Scenario | Interpretation |
+|----------|----------------|
+| High req, low code | Requirements covered but implementation gaps; possible dead code or missing automation |
+| High code, low req | Code well-tested but not traced to requirements; traceability gap |
+| High req+code, low technique | May lack variety; consider EP, BVA, DT, ST for same areas |
+| All low | Systemic gap; prioritize by risk |
+
+---
+
+## Risk-Based Prioritization
+
+Apply risk (from qa-test-strategy `references/risk-matrix.md`) to prioritize gaps:
+
+- **High-risk + uncovered** → First priority
+- **High-risk + low technique** → Add technique variety
+- **Low-risk + uncovered** → Defer or accept

package/skills/qa-coverage-analyzer/references/tools.md

@@ -0,0 +1,204 @@
+# Coverage Tools Reference
+
+Reference for code coverage tools: Istanbul, V8, JaCoCo, coverage.py, and SonarQube. Use for parsing reports and configuring coverage analysis.
+
+---
+
+## JavaScript / TypeScript
+
+### Istanbul (nyc / c8)
+
+**Purpose:** Line, branch, function, statement coverage for Node.js and browser tests.
+
+**Install:**
+```bash
+npm install -D c8
+# or
+npm install -D nyc
+```
+
+**Run:**
+```bash
+c8 npm test
+# or
+nyc npm test
+```
+
+**Report formats:** JSON, LCOV, HTML, text-summary
+
+**Output location:** `coverage/` (default)
+
+**Key config (package.json or .nycrc):**
+```json
+{
+  "coverage": {
+    "reporter": ["text", "lcov", "html"],
+    "exclude": ["**/*.test.js", "**/node_modules/**"]
+  }
+}
+```
+
+### V8 Native Coverage
+
+**Purpose:** Native V8 coverage (Chrome/Node); often used with Vitest, Jest, or Playwright.
+
+**Vitest:**
+```javascript
+// vitest.config.ts
+export default {
+  test: {
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'json', 'html'],
+      exclude: ['node_modules', '**/*.spec.ts']
+    }
+  }
+}
+```
+
+**Jest (with v8):**
+```javascript
+// jest.config.js
+module.exports = {
+  collectCoverageFrom: ['src/**/*.{js,ts}'],
+  coverageProvider: 'v8',
+  coverageReporters: ['text', 'lcov', 'html']
+};
+```
+
+**Report formats:** V8 format, LCOV, HTML
+
+---
+
+## Java
+
+### JaCoCo
+
+**Purpose:** Line, branch, instruction coverage for JVM languages (Java, Kotlin, Scala).
+
+**Maven:**
+```xml
+<plugin>
+  <groupId>org.jacoco</groupId>
+  <artifactId>jacoco-maven-plugin</artifactId>
+  <version>0.8.11</version>
+  <executions>
+    <execution>
+      <goals><goal>prepare-agent</goal></goals>
+      <configuration>
+        <destFile>${project.build.directory}/jacoco.exec</destFile>
+      </configuration>
+    </execution>
+    <execution>
+      <id>report</id>
+      <phase>test</phase>
+      <goals><goal>report</goal></goals>
+    </execution>
+  </executions>
+</plugin>
+```
+
+**Gradle:**
+```groovy
+plugins {
+  id 'jacoco'
+}
+jacoco {
+  toolVersion = "0.8.11"
+}
+test {
+  finalizedBy jacocoTestReport
+}
+```
+
+**Report formats:** XML, HTML, CSV
+
+**Output:** `target/site/jacoco/` (Maven), `build/reports/jacoco/` (Gradle)
+
+**Parsing:** XML report contains `<package>`, `<class>`, `<counter type="LINE">` etc.
+
+---
+
+## Python
+
+### coverage.py
+
+**Purpose:** Line and branch coverage for Python.
+
+**Install:**
+```bash
+pip install coverage
+```
+
+**Run:**
+```bash
+coverage run -m pytest
+coverage report
+coverage html
+```
+
+**Config (.coveragerc or pyproject.toml):**
+```ini
+[run]
+source = src
+omit = */tests/*, */venv/*
+
+[report]
+exclude_lines =
+    pragma: no cover
+    def __repr__
+```
+
+**Report formats:** XML (Cobertura), HTML, JSON
+
+**Output:** `htmlcov/`, `coverage.xml`
+
+**Branch coverage:**
+```bash
+coverage run --branch -m pytest
+```
+
+---
+
+## SonarQube
+
+**Purpose:** Centralized quality and coverage across languages. Aggregates coverage from Istanbul, JaCoCo, coverage.py, etc.
+
+**Setup:**
+1. Run SonarQube server (Docker or standalone)
+2. Configure `sonar-project.properties`:
+```properties
+sonar.projectKey=my-project
+sonar.sources=src
+sonar.tests=test
+sonar.javascript.lcov.reportPaths=coverage/lcov.info
+sonar.java.jacoco.reportPaths=target/site/jacoco/jacoco.xml
+sonar.python.coverage.reportPaths=coverage.xml
+```
+3. Run scanner: `sonar-scanner`
+
+**Coverage sources:** LCOV (JS/TS), JaCoCo XML (Java), Cobertura/coverage.xml (Python)
+
+**Use for:** Unified dashboard, quality gates, trend tracking
+
+---
+
+## Report Parsing Tips
+
+| Tool | Key File | Structure |
+|------|----------|-----------|
+| Istanbul/c8 | coverage/coverage-final.json | `[file path]: { s: statements, f: functions, b: branches }` |
+| JaCoCo | jacoco.xml | `<package name="">` → `<class>` → `<counter type="LINE" missed="..." covered="..."/>` |
+| coverage.py | coverage.xml | Cobertura format: `<packages>` → `<package>` → `<classes>` → `<line number="..." hits="..."/>` |
+| SonarQube | API / scanner output | Use Sonar API or scanner for aggregated metrics |
+
+---
+
+## CI Integration
+
+| CI | Example |
+|----|---------|
+| GitHub Actions | `npm run test:coverage` → upload `coverage/` artifact |
+| GitLab CI | `coverage: '/Lines:\s+(\d+\.?\d*)%/'` in job |
+| Jenkins | Publish HTML/LCOV/XML; use Coverage plugin |
+| Azure Pipelines | Publish Code Coverage task with format (Cobertura, JaCoCo) |

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

@@ -0,0 +1,134 @@
+---
+name: qa-cypress-writer
+description: Generate Cypress E2E and component tests for TypeScript with time-travel debugging, cy.intercept for network mocking, and component testing via cy.mount.
+output_dir: tests/e2e
+---
+
+# QA Cypress Writer
+
+## Purpose
+
+Write Cypress E2E and component tests from test case specifications. Transform structured test cases into executable TypeScript test files with proper selectors, network mocking, and component isolation.
+
+## Trigger Phrases
+
+- "Write Cypress tests for [feature/page]"
+- "Generate Cypress E2E tests from test cases"
+- "Create Cypress component tests for [component]"
+- "Add Cypress tests with cy.intercept for [API]"
+- "Cypress tests with cy.mount for [React/Vue component]"
+- "Cypress E2E test file for [flow]"
+- "Cypress custom commands for [login/fillForm]"
+
+## Test Types
+
+| Type | Scope | When to Use |
+|------|-------|-------------|
+| **E2E** | Full user flows, page navigation | Critical paths, user journeys |
+| **Component** | Isolated UI components | React/Vue/Angular/Svelte components |
+
+## Workflow
+
+1. **Read test cases** — From Phase 2 (qa-testcase-from-docs, qa-manual-test-designer, qa-browser-data-collector)
+2. **Analyze target** — Page structure, API endpoints, component props/events
+3. **Generate test files** — Create `*.cy.ts` in `cypress/e2e/` or `cypress/component/`
+4. **Add intercepts/fixtures** — `cy.intercept()`, `cy.fixture()` for network control
+5. **Verify selectors** — Prefer `data-cy` attributes; avoid brittle CSS
+
+## Context7 MCP
+
+Uses Context7 MCP to fetch current Cypress documentation when needed. Query for Cypress API, commands, or configuration when patterns are unclear.
+
+## E2E Testing
+
+- **Navigation:** `cy.visit()`, `cy.go()`, `cy.reload()`
+- **Queries:** `cy.get()`, `cy.contains()`, `cy.find()` — chainable, retry-able
+- **Actions:** `cy.click()`, `cy.type()`, `cy.clear()`, `cy.select()`, `cy.check()`
+- **Chained commands** — Each command retries until timeout; enables time-travel debugging
+- **Retry-ability** — Cypress automatically retries assertions and queries
+
+## Component Testing
+
+- **cy.mount()** — Mount React/Vue/Angular/Svelte components in isolation
+- **Props/events/slots** — Test component behavior without full app
+- **Dev server** — Uses `component.devServer` in config (Vite, Webpack, etc.)
+
+## Network Mocking
+
+- **cy.intercept()** — Stub, spy, or wait for HTTP requests
+- **Fixtures** — `cy.fixture()` for response data; `cy.intercept('GET', '/api/users', { fixture: 'users.json' })`
+- **Aliases** — `cy.intercept('GET', '/api/users').as('getUsers')`; `cy.wait('@getUsers')`
+
+## Custom Commands
+
+- **Cypress.Commands.add()** — Reusable actions: `cy.login()`, `cy.fillForm()`, `cy.logout()`
+- **Declare in cypress/support/commands.ts** — Extend Cypress namespace for TypeScript
+
+## Key Patterns
+
+- **Structure:** `describe` / `it`, `beforeEach` / `afterEach`
+- **Auth:** `cy.session()` for login state caching (Cypress 8+)
+- **Screenshots:** `cy.screenshot()` for debugging; auto on failure
+- **Data attributes:** `data-cy="submit-btn"` for stable selectors
+- **Assertions:** Explicit `should()` / `expect()`; avoid implicit passes
+
+## Configuration
+
+- **cypress.config.ts** — `baseUrl`, `viewportWidth`/`viewportHeight`, `video`, `retries`, `component.devServer`
+- **Support files** — `cypress/support/e2e.ts`, `commands.ts`
+
+See `references/config.md` for full configuration guide.
+
+## File Naming
+
+- `cypress/e2e/{feature}.cy.ts` — E2E tests
+- `cypress/component/{Component}.cy.tsx` — Component tests
+
+## References
+
+- `references/patterns.md` — E2E flows, component mounting, custom commands, fixtures, aliases
+- `references/assertions.md` — should, expect, assert patterns (Chai)
+- `references/config.md` — cypress.config.ts, env, plugins, support files
+- `references/best-practices.md` — data-cy, anti-patterns, flake prevention, CI
+
+## Scope
+
+**Can do (autonomous):**
+- Generate Cypress E2E and component tests from test cases
+- Add `cy.intercept()` for API stubbing/spying
+- Create custom commands in `commands.ts`
+- Use `cy.fixture()` and `cy.session()` where appropriate
+- Configure `cypress.config.ts` for baseUrl, viewport, retries
+- Add `data-cy` selectors in generated tests (recommend adding to app if missing)
+
+**Cannot do (requires confirmation):**
+- Modify production code to add `data-cy` attributes
+- Change existing Cypress config without user approval
+- Add tests for flows/components not in scope
+
+**Will not do (out of scope):**
+- Unit tests (use qa-jest-writer)
+- Visual regression (use dedicated tools)
+- Modify application deployment or runtime
+
+## Quality Checklist
+
+- [ ] No `cy.wait(ms)` — use `cy.wait('@alias')` or assertions instead
+- [ ] Use `data-cy` attributes for selectors where possible
+- [ ] Assertions explicit — every meaningful step has assertion
+- [ ] No cross-test dependencies — tests run in any order
+- [ ] Proper cleanup — no leftover state between tests
+- [ ] Intercepts scoped — avoid global intercepts that leak
+- [ ] Descriptive test names — "should display error when login fails"
+
+## Troubleshooting
+
+| Symptom | Likely Cause | Fix |
+|---------|--------------|-----|
+| Element not found | Selector too brittle or timing | Use `data-cy`; ensure element exists before action; increase timeout if needed |
+| cy.wait(ms) flakiness | Arbitrary delays | Replace with `cy.wait('@alias')` or `should()` assertions |
+| Intercept not matching | URL/pattern mismatch | Use `cy.intercept('**/api/users*')` or exact URL; check method |
+| Session not persisting | cy.session misconfigured | Ensure `cy.session()` in `beforeEach`; validate cache key |
+| Component mount fails | Missing provider/wrapper | Add providers in `cy.mount(<Provider><Component /></Provider>)` |
+| Cross-origin errors | Navigating to different domain | Use `cy.origin()` for cross-origin flows |
+| Timeout on assertion | Element never meets condition | Verify selector; check if element is in iframe (not supported) |

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

@@ -0,0 +1,121 @@
+# Cypress / Chai Assertion Reference
+
+Cypress uses Chai assertions. Two styles: `should` (BDD) and `expect` / `assert` (TDD).
+
+---
+
+## should (BDD, chained)
+
+```typescript
+cy.get('[data-cy="title"]').should('have.text', 'Welcome');
+cy.get('input').should('have.value', 'test').and('be.visible');
+cy.get('button').should('be.disabled').and('have.class', 'primary');
+```
+
+---
+
+## expect (TDD, explicit)
+
+```typescript
+cy.get('[data-cy="count"]').then(($el) => {
+  expect($el.text()).to.eq('5');
+  expect($el).to.be.visible;
+});
+```
+
+---
+
+## assert (TDD, explicit)
+
+```typescript
+cy.get('body').then(($body) => {
+  assert.isTrue($body.find('[data-cy="success"]').length > 0);
+});
+```
+
+---
+
+## Common Assertions by Category
+
+### DOM / Visibility
+
+| Assertion | Example |
+|-----------|---------|
+| `be.visible` | `cy.get('el').should('be.visible')` |
+| `be.hidden` | `cy.get('el').should('be.hidden')` |
+| `exist` | `cy.get('el').should('exist')` |
+| `not.exist` | `cy.get('el').should('not.exist')` |
+
+### Text / Content
+
+| Assertion | Example |
+|-----------|---------|
+| `have.text` | `cy.get('el').should('have.text', 'Hello')` |
+| `contain` | `cy.get('el').should('contain', 'partial')` |
+| `include.text` | `cy.get('el').should('include.text', 'partial')` |
+
+### Attributes / Properties
+
+| Assertion | Example |
+|-----------|---------|
+| `have.attr` | `cy.get('el').should('have.attr', 'href', '/home')` |
+| `have.class` | `cy.get('el').should('have.class', 'active')` |
+| `have.value` | `cy.get('input').should('have.value', 'typed')` |
+| `have.css` | `cy.get('el').should('have.css', 'display', 'block')` |
+
+### State
+
+| Assertion | Example |
+|-----------|---------|
+| `be.disabled` | `cy.get('button').should('be.disabled')` |
+| `be.enabled` | `cy.get('button').should('be.enabled')` |
+| `be.checked` | `cy.get('checkbox').should('be.checked')` |
+| `be.focused` | `cy.get('input').should('be.focused')` |
+
+### Length / Count
+
+| Assertion | Example |
+|-----------|---------|
+| `have.length` | `cy.get('li').should('have.length', 5)` |
+| `have.length.greaterThan` | `cy.get('li').should('have.length.greaterThan', 0)` |
+
+### URL
+
+| Assertion | Example |
+|-----------|---------|
+| `include` | `cy.url().should('include', '/dashboard')` |
+| `eq` | `cy.url().should('eq', 'https://app.example.com/')` |
+
+### Negation
+
+Prepend `not.`:
+
+```typescript
+cy.get('el').should('not.be.visible');
+cy.get('el').should('not.contain', 'Error');
+```
+
+---
+
+## Chaining Assertions
+
+```typescript
+cy.get('[data-cy="card"]')
+  .should('be.visible')
+  .and('have.class', 'highlighted')
+  .and('contain', 'Success');
+```
+
+---
+
+## Custom Chai Assertions
+
+```typescript
+chai.use((chai, utils) => {
+  chai.Assertion.addMethod('validEmail', function () {
+    const obj = this._obj;
+    const pass = /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(obj);
+    this.assert(pass, 'expected #{this} to be valid email', 'expected #{this} not to be valid email');
+  });
+});
+```

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

@@ -0,0 +1,82 @@
+# Cypress Best Practices
+
+## Selecting Elements
+
+### Prefer data-cy Attributes
+
+```typescript
+// Good — stable, test-specific
+cy.get('[data-cy="submit-button"]').click();
+cy.get('[data-cy="user-email"]').type('test@example.com');
+
+// Avoid — brittle
+cy.get('.btn-primary').click();
+cy.get('#email').type('test@example.com');
+cy.get('div > span:nth-child(2)').click();
+```
+
+Add `data-cy` to production markup or via build step. Never rely solely on CSS classes or structure that may change.
+
+---
+
+## Anti-Patterns to Avoid
+
+### No cy.wait(ms)
+
+```typescript
+// Bad — flaky, arbitrary delay
+cy.wait(3000);
+cy.get('[data-cy="results"]').click();
+
+// Good — wait for condition or request
+cy.intercept('GET', '/api/results').as('getResults');
+cy.visit('/dashboard');
+cy.wait('@getResults');
+cy.get('[data-cy="results"]').should('be.visible').click();
+```
+
+### No Cross-Test Dependencies
+
+Each test must be independent. Do not rely on execution order or shared mutable state.
+
+```typescript
+// Bad
+let sharedId;
+it('creates item', () => { sharedId = ...; });
+it('edits item', () => { cy.visit(`/items/${sharedId}`); });
+
+// Good
+it('edits item', () => {
+  cy.login();
+  cy.createItemViaApi({ name: 'Test' }).then((id) => {
+    cy.visit(`/items/${id}`);
+    // ...
+  });
+});
+```
+
+### Proper Cleanup
+
+- Use `beforeEach` / `afterEach` for setup and teardown
+- Use `cy.session()` for login to cache auth across tests
+- Reset DB or use isolated test data when possible
+
+---
+
+## Flake Prevention
+
+1. **Assert before acting** — Ensure element is ready before click/type
+2. **Use aliases for async** — `cy.wait('@alias')` instead of fixed delays
+3. **Retry-ability** — Chain assertions; Cypress retries until timeout
+4. **Avoid testing third-party** — Mock external APIs with `cy.intercept`
+5. **Stable selectors** — `data-cy` over classes/IDs that change
+
+---
+
+## CI Setup
+
+- Set `baseUrl` via `CYPRESS_BASE_URL` or `env.baseUrl`
+- Use `retries: { runMode: 2 }` for transient failures
+- Enable `video: true` and archive on failure
+- Run in parallel with `cypress run --record` (Cypress Dashboard)
+- Use `--config viewportWidth=1280` for consistent viewport