qa-skills 3.0.0

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

@@ -0,0 +1,121 @@
+# Cypress Configuration
+
+## cypress.config.ts
+
+```typescript
+import { defineConfig } from 'cypress';
+
+export default defineConfig({
+  e2e: {
+    baseUrl: 'https://app.example.com',
+    viewportWidth: 1280,
+    viewportHeight: 720,
+    video: true,
+    screenshotOnRunFailure: true,
+    retries: {
+      runMode: 2,
+      openMode: 0,
+    },
+    setupNodeEvents(on, config) {
+      // implement node event listeners here
+    },
+  },
+  component: {
+    devServer: {
+      framework: 'react',
+      bundler: 'vite',
+    },
+    specPattern: 'src/**/*.cy.{ts,tsx}',
+  },
+});
+```
+
+---
+
+## Key Options
+
+| Option | Description | Example |
+|--------|-------------|---------|
+| `baseUrl` | Base URL for `cy.visit()` | `'https://staging.example.com'` |
+| `viewportWidth` / `viewportHeight` | Default viewport size | `1280`, `720` |
+| `video` | Record video of runs | `true` / `false` |
+| `screenshotOnRunFailure` | Capture screenshot on failure | `true` |
+| `retries` | Retry failed tests (runMode for CI, openMode for UI) | `{ runMode: 2, openMode: 0 }` |
+| `defaultCommandTimeout` | Timeout for commands (ms) | `4000` |
+| `pageLoadTimeout` | Timeout for page load (ms) | `60000` |
+| `requestTimeout` | Timeout for `cy.request()` (ms) | `5000` |
+
+---
+
+## Environment Variables
+
+### In cypress.config.ts
+
+```typescript
+export default defineConfig({
+  env: {
+    apiUrl: 'https://api.example.com',
+    testUser: 'qa@example.com',
+  },
+});
+```
+
+### Usage in Tests
+
+```typescript
+cy.log(Cypress.env('apiUrl'));
+cy.request(Cypress.env('apiUrl') + '/health');
+```
+
+### Override via CLI
+
+```bash
+cypress run --env apiUrl=https://staging-api.example.com
+```
+
+---
+
+## Plugins (setupNodeEvents)
+
+```typescript
+setupNodeEvents(on, config) {
+  on('task', {
+    log(message) {
+      console.log(message);
+      return null;
+    },
+  });
+  return config;
+}
+```
+
+---
+
+## Support Files
+
+| File | Purpose |
+|------|---------|
+| `cypress/support/e2e.ts` | Runs before every E2E spec (imports, global config) |
+| `cypress/support/commands.ts` | Custom commands |
+| `cypress/support/component.ts` | Runs before component specs |
+
+### e2e.ts Example
+
+```typescript
+import './commands';
+
+beforeEach(() => {
+  cy.intercept('GET', '/api/config', { fixture: 'config.json' });
+});
+```
+
+---
+
+## Component Testing Dev Server
+
+| Framework | Config |
+|-----------|--------|
+| React + Vite | `framework: 'react', bundler: 'vite'` |
+| Vue + Vite | `framework: 'vue', bundler: 'vite'` |
+| Angular | `framework: 'angular', bundler: '@angular-devkit/build-angular'` |
+| Svelte | `framework: 'svelte', bundler: 'vite'` |

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

@@ -0,0 +1,170 @@
+# Cypress Test Patterns
+
+## E2E Flows
+
+### Basic Page Visit and Interaction
+
+```typescript
+describe('Login flow', () => {
+  it('logs in successfully', () => {
+    cy.visit('/login');
+    cy.get('[data-cy="email-input"]').type('user@example.com');
+    cy.get('[data-cy="password-input"]').type('secret');
+    cy.get('[data-cy="submit-btn"]').click();
+    cy.url().should('include', '/dashboard');
+    cy.contains('Welcome').should('be.visible');
+  });
+});
+```
+
+### Chained Commands and Retry-ability
+
+Cypress automatically retries commands until assertions pass or timeout:
+
+```typescript
+cy.get('[data-cy="loading"]').should('not.exist');
+cy.get('[data-cy="results"]').should('be.visible').and('contain', 'Success');
+```
+
+### Time-Travel Debugging
+
+Use `.pause()` or Cypress UI to step through commands and inspect DOM at each step.
+
+---
+
+## Component Testing
+
+### React with cy.mount()
+
+```typescript
+import { mount } from 'cypress/react18';
+import { Button } from './Button';
+
+describe('Button', () => {
+  it('calls onClick when clicked', () => {
+    const onClick = cy.stub();
+    cy.mount(<Button label="Submit" onClick={onClick} />);
+    cy.get('[data-cy="button"]').click();
+    cy.wrap(onClick).should('have.been.calledOnce');
+  });
+
+  it('renders with custom props', () => {
+    cy.mount(<Button label="Save" disabled />);
+    cy.get('[data-cy="button"]').should('be.disabled');
+  });
+});
+```
+
+### Vue with cy.mount()
+
+```typescript
+import { mount } from 'cypress/vue';
+import HelloWorld from './HelloWorld.vue';
+
+describe('HelloWorld', () => {
+  it('emits event on click', () => {
+    cy.mount(HelloWorld, { props: { msg: 'Hello' } });
+    cy.get('button').click();
+    cy.get('@emitSpy').should('have.been.calledWith', 'greet');
+  });
+});
+```
+
+### Slots and Events
+
+```typescript
+cy.mount(Component, {
+  props: { title: 'Test' },
+  slots: { default: '<span>Slot content</span>' },
+});
+```
+
+---
+
+## Custom Commands
+
+### Defining Commands (cypress/support/commands.ts)
+
+```typescript
+Cypress.Commands.add('login', (email: string, password: string) => {
+  cy.session([email, password], () => {
+    cy.visit('/login');
+    cy.get('[data-cy="email-input"]').type(email);
+    cy.get('[data-cy="password-input"]').type(password);
+    cy.get('[data-cy="submit-btn"]').click();
+    cy.url().should('include', '/dashboard');
+  });
+});
+
+Cypress.Commands.add('fillForm', (selector: string, data: Record<string, string>) => {
+  Object.entries(data).forEach(([name, value]) => {
+    cy.get(`${selector} [data-cy="${name}"]`).clear().type(value);
+  });
+});
+```
+
+### Using Custom Commands
+
+```typescript
+beforeEach(() => {
+  cy.login('user@example.com', 'password');
+});
+
+it('creates a new item', () => {
+  cy.visit('/items/new');
+  cy.fillForm('[data-cy="item-form"]', { name: 'Item 1', description: 'Desc' });
+  cy.get('[data-cy="save-btn"]').click();
+});
+```
+
+---
+
+## Fixtures
+
+### Loading Fixtures
+
+```typescript
+cy.fixture('users.json').then((users) => {
+  cy.get('[data-cy="user-select"]').select(users[0].name);
+});
+```
+
+### With cy.intercept
+
+```typescript
+cy.fixture('users.json').as('users');
+cy.intercept('GET', '/api/users', { fixture: 'users.json' }).as('getUsers');
+cy.visit('/users');
+cy.wait('@getUsers');
+```
+
+---
+
+## Aliases and cy.wait(@alias)
+
+### Request Aliases
+
+```typescript
+cy.intercept('POST', '/api/orders').as('createOrder');
+cy.get('[data-cy="checkout"]').click();
+cy.wait('@createOrder').its('response.statusCode').should('eq', 201);
+```
+
+### Fixture Aliases
+
+```typescript
+cy.fixture('order.json').as('orderData');
+cy.get('@orderData').then((data) => {
+  cy.get('[data-cy="order-id"]').type(data.id);
+});
+```
+
+---
+
+## Assertions in E2E
+
+```typescript
+cy.get('[data-cy="count"]').should('have.text', '5');
+cy.get('form').should('have.class', 'valid');
+cy.get('[data-cy="list"]').find('li').should('have.length', 3);
+```

package/skills/qa-data-factory/SKILL.md

@@ -0,0 +1,126 @@
+---
+name: qa-data-factory
+description: Generate realistic test data using fixtures, factory patterns, and faker-based seeds for consistent and reproducible test environments.
+output_dir: data/fixtures
+---
+
+# QA Data Factory
+
+## Purpose
+
+Generate realistic, consistent, and reproducible test data for automated and manual testing. Supports fixtures (static JSON/YAML), factory patterns (dynamic generation with overrides), faker-based seeds (realistic random data), and builder patterns (fluent API for complex objects). Produces fixtures, factory classes, seed scripts, and data cleanup utilities.
+
+## Trigger Phrases
+
+- "Generate test data for [entity type]"
+- "Create fixtures for [Users/Products/Orders]"
+- "Factory pattern for test data"
+- "Faker-based seed data"
+- "Test data builder for [complex object]"
+- "Realistic test data with locale [en_US/de_DE]"
+- "Seed script for test database"
+- "Data cleanup utilities for tests"
+
+## Data Generation Approaches
+
+| Approach | Use Case | Output |
+|----------|----------|--------|
+| **Fixtures** | Static, version-controlled data; predictable | JSON, YAML, CSV files |
+| **Factory pattern** | Dynamic generation with overrides; per-test customization | Factory classes (TypeScript/Python) |
+| **Faker-based seeds** | Realistic but random; locale-aware | Seed scripts, inline generation |
+| **Builder pattern** | Complex nested objects; fluent API | Builder classes |
+
+See `references/factory-patterns.md` for implementation details.
+
+## TypeScript Tools
+
+| Tool | Purpose |
+|------|---------|
+| **@faker-js/faker** | Realistic random data (names, emails, addresses, dates) |
+| **fishery** | Factory pattern with sequences and traits |
+| **factory.ts** | TypeScript factories with associations |
+| **Test data builders** | Fluent API for complex objects |
+
+## Python Tools
+
+| Tool | Purpose |
+|------|---------|
+| **Faker** | Realistic random data; locale support |
+| **factory_boy** | Factory pattern with sequences, subfactories |
+| **pytest-factoryboy** | Pytest integration; fixtures from factories |
+| **model_bakery** | Django model factories; minimal boilerplate |
+
+See `references/faker-guide.md` for usage patterns.
+
+## Data Types Supported
+
+| Type | Examples | Locale-aware |
+|------|----------|--------------|
+| **Users** | name, email, username, password hash | Yes (names, formats) |
+| **Products** | SKU, title, price, category | Yes (currency, formats) |
+| **Orders** | order ID, items, totals, status | Yes (dates, currency) |
+| **Addresses** | street, city, postal code, country | Yes |
+| **Payment info** | card numbers (test), expiry, CVV | Test card patterns |
+| **Dates** | birthdate, created_at, expiry | Yes (formats) |
+| **Emails** | valid format, domain | Yes |
+| **Names** | first, last, full | Yes (locale-specific) |
+
+## Output Artifacts
+
+1. **Test data fixtures** — Static JSON/YAML/CSV for predictable scenarios
+2. **Factory classes** — TypeScript or Python factories with overrides
+3. **Seed scripts** — Scripts to populate test DB with faker data
+4. **Data cleanup utilities** — Teardown scripts, truncate/reset helpers
+
+## Workflow
+
+1. **Identify data needs** — Entity types, required fields, relationships
+2. **Choose approach** — Fixtures vs factory vs faker based on use case
+3. **Select tools** — Match project stack (TS/Python, framework)
+4. **Generate artifacts** — Fixtures, factories, seed scripts
+5. **Add cleanup** — Teardown for isolation between test runs
+
+## Scope
+
+**Can do (autonomous):**
+- Generate fixtures, factories, seed scripts for specified entities
+- Use Faker/faker-js for realistic locale-aware data
+- Produce TypeScript (fishery, factory.ts) and Python (factory_boy, Faker) code
+- Create data cleanup utilities
+- Reference factory-patterns and faker-guide
+
+**Cannot do (requires confirmation):**
+- Add new dependencies without approval
+- Modify production schemas or migrations
+- Generate data for proprietary/restricted formats
+
+**Will not do (out of scope):**
+- Execute seed scripts or modify databases directly
+- Generate production data or PII
+- Bypass data validation or security constraints
+
+## References
+
+| Topic | File |
+|-------|------|
+| Factory pattern implementations (TS, Python) | `references/factory-patterns.md` |
+| Faker library usage for realistic data | `references/faker-guide.md` |
+
+## Quality Checklist
+
+- [ ] Generated data matches entity schema/contract
+- [ ] Locale specified when names/addresses/formats matter
+- [ ] No real PII or production-like secrets
+- [ ] Fixtures are deterministic; faker seeds use configurable seed for reproducibility
+- [ ] Cleanup utilities included for test isolation
+- [ ] Factory overrides documented for common scenarios
+
+## Troubleshooting
+
+| Symptom | Likely Cause | Fix |
+|---------|--------------|-----|
+| Data conflicts between tests | Shared state; no cleanup | Add teardown; use unique IDs/emails per test |
+| Unrealistic data | Default faker; wrong locale | Set locale; use appropriate faker providers |
+| Factory too verbose | Over-specification | Use sensible defaults; override only when needed |
+| Seed non-reproducible | Random seed not set | Use faker.seed(123) or equivalent |
+| Schema mismatch | Generated fields don't match API/DB | Align with OpenAPI/DB schema; validate output |

package/skills/qa-data-factory/references/factory-patterns.md

@@ -0,0 +1,164 @@
+# Factory Pattern Implementations for Test Data
+
+## Overview
+
+Factory patterns enable dynamic generation of test data with sensible defaults and per-test overrides. This document covers TypeScript and Python implementations.
+
+---
+
+## TypeScript: fishery
+
+```typescript
+import { Factory } from 'fishery';
+import type { User } from '../types';
+
+export const UserFactory = Factory.define<User>(({ sequence }) => ({
+  id: sequence,
+  email: `user${sequence}@example.com`,
+  name: `User ${sequence}`,
+  createdAt: new Date(),
+}));
+
+// Usage
+const user = UserFactory.build();
+const admin = UserFactory.build({ role: 'admin' });
+const users = UserFactory.buildList(5);
+```
+
+### Traits
+
+```typescript
+export const UserFactory = Factory.define<User>(({ sequence, traits }) => ({
+  id: sequence,
+  email: `user${sequence}@example.com`,
+  name: `User ${sequence}`,
+  role: 'user',
+})).trait('admin', { role: 'admin' })
+  .trait('inactive', { status: 'inactive' });
+
+// Usage
+const admin = UserFactory.build({}, { traits: ['admin'] });
+```
+
+---
+
+## TypeScript: factory.ts
+
+```typescript
+import { factory } from 'factory.ts';
+import type { Product } from '../types';
+
+export const ProductFactory = factory.make<Product>(s => ({
+  id: s.sequence(),
+  sku: `SKU-${s.sequence()}`,
+  title: `Product ${s.sequence()}`,
+  price: 9.99,
+  inStock: true,
+}));
+
+// Usage
+const product = ProductFactory.build();
+const expensive = ProductFactory.build({ price: 999 });
+```
+
+---
+
+## Python: factory_boy
+
+```python
+import factory
+from myapp.models import User
+
+class UserFactory(factory.Factory):
+    class Meta:
+        model = User
+
+    id = factory.Sequence(lambda n: n)
+    email = factory.Sequence(lambda n: f'user{n}@example.com')
+    name = factory.Sequence(lambda n: f'User {n}')
+    role = 'user'
+
+# Usage
+user = UserFactory()
+admin = UserFactory(role='admin')
+users = UserFactory.create_batch(5)
+```
+
+### Subfactories and LazyAttribute
+
+```python
+class OrderFactory(factory.Factory):
+    class Meta:
+        model = Order
+
+    user = factory.SubFactory(UserFactory)
+    total = factory.LazyAttribute(lambda o: sum(i.price for i in o.items))
+```
+
+---
+
+## Python: pytest-factoryboy
+
+```python
+# conftest.py
+import pytest
+from .factories import UserFactory
+
+@pytest.fixture
+def user(db):
+    return UserFactory()
+
+@pytest.fixture
+def admin_user(db):
+    return UserFactory(role='admin')
+```
+
+---
+
+## Builder Pattern (TypeScript)
+
+```typescript
+class UserBuilder {
+  private data: Partial<User> = {};
+
+  withId(id: number) {
+    this.data.id = id;
+    return this;
+  }
+  withEmail(email: string) {
+    this.data.email = email;
+    return this;
+  }
+  asAdmin() {
+    this.data.role = 'admin';
+    return this;
+  }
+  build(): User {
+    return { id: 1, email: 'default@example.com', role: 'user', ...this.data };
+  }
+}
+
+// Usage
+const user = new UserBuilder().withEmail('test@example.com').asAdmin().build();
+```
+
+---
+
+## Builder Pattern (Python)
+
+```python
+class UserBuilder:
+    def __init__(self):
+        self._data = {}
+
+    def with_email(self, email: str):
+        self._data['email'] = email
+        return self
+
+    def as_admin(self):
+        self._data['role'] = 'admin'
+        return self
+
+    def build(self) -> dict:
+        return {'id': 1, 'email': 'default@example.com', 'role': 'user', **self._data}
+```

package/skills/qa-data-factory/references/faker-guide.md

@@ -0,0 +1,131 @@
+# Faker Library Usage Guide for Realistic Test Data
+
+## Overview
+
+Faker libraries generate realistic-looking random data for names, addresses, emails, dates, and more. Support for multiple locales ensures culturally appropriate data.
+
+---
+
+## TypeScript: @faker-js/faker
+
+### Basic Usage
+
+```typescript
+import { faker } from '@faker-js/faker';
+
+// Names
+faker.person.fullName();      // "John Doe"
+faker.person.firstName();     // "Jane"
+faker.internet.email();       // "john.doe@example.com"
+
+// Addresses
+faker.location.streetAddress();
+faker.location.city();
+faker.location.country();
+
+// Dates
+faker.date.past();
+faker.date.between({ from: '2020-01-01', to: '2024-12-31' });
+```
+
+### Locale
+
+```typescript
+import { faker } from '@faker-js/faker/locale/de';
+
+faker.person.fullName();  // German names
+faker.location.city();   // German cities
+```
+
+### Reproducibility (Seed)
+
+```typescript
+faker.seed(12345);
+const name1 = faker.person.fullName();
+faker.seed(12345);
+const name2 = faker.person.fullName();
+// name1 === name2
+```
+
+### Common Providers
+
+| Provider | Example |
+|----------|---------|
+| `faker.person.*` | fullName, firstName, lastName |
+| `faker.internet.*` | email, userName, url |
+| `faker.finance.*` | creditCardNumber, iban (test patterns) |
+| `faker.commerce.*` | productName, price, department |
+| `faker.string.uuid()` | UUID |
+| `faker.number.int({ min, max })` | Bounded integers |
+
+---
+
+## Python: Faker
+
+### Basic Usage
+
+```python
+from faker import Faker
+
+fake = Faker()
+
+# Names
+fake.name()
+fake.first_name()
+fake.last_name()
+
+# Emails and internet
+fake.email()
+fake.user_name()
+fake.url()
+
+# Addresses
+fake.street_address()
+fake.city()
+fake.country()
+```
+
+### Locale
+
+```python
+fake_de = Faker('de_DE')
+fake_de.name()   # German names
+fake_de.city()   # German cities
+```
+
+### Reproducibility (Seed)
+
+```python
+Faker.seed(12345)
+name1 = fake.name()
+Faker.seed(12345)
+name2 = fake.name()
+# name1 == name2
+```
+
+### Common Providers
+
+| Provider | Example |
+|----------|---------|
+| `fake.name()`, `fake.first_name()` | Names |
+| `fake.email()`, `fake.user_name()` | Internet |
+| `fake.street_address()`, `fake.city()` | Addresses |
+| `fake.credit_card_number()` | Test card numbers |
+| `fake.uuid4()` | UUID |
+| `fake.date_between()`, `fake.date_time_between()` | Dates |
+| `fake.random_int(min=1, max=100)` | Integers |
+
+---
+
+## Test Card Numbers
+
+Use provider-specific test patterns (e.g., 4111... for Visa test cards). Never use real card numbers.
+
+---
+
+## Best Practices
+
+1. **Set seed** for reproducible test runs when debugging.
+2. **Use locale** when testing i18n or region-specific formats.
+3. **Avoid PII** — generated data should not resemble real people.
+4. **Unique identifiers** — use sequences or UUIDs when uniqueness matters.