@agentic-qe/v3 3.0.0-alpha.10

package/assets/skills/test-automation-strategy/SKILL.md

@@ -0,0 +1,230 @@
+---
+name: test-automation-strategy
+description: "Design and implement effective test automation with proper pyramid, patterns, and CI/CD integration. Use when building automation frameworks or improving test efficiency."
+category: testing-methodologies
+priority: high
+tokenEstimate: 1000
+agents: [qe-test-generator, qe-test-executor, qe-coverage-analyzer, qe-flaky-test-hunter, qe-regression-risk-analyzer]
+implementation_status: optimized
+optimization_version: 1.0
+last_optimized: 2025-12-02
+dependencies: []
+quick_reference_card: true
+tags: [automation, test-pyramid, page-object, first-principles, ci-cd, flaky-tests]
+---
+
+# Test Automation Strategy
+
+<default_to_action>
+When designing or improving test automation:
+1. FOLLOW test pyramid: 70% unit, 20% integration, 10% E2E
+2. APPLY F.I.R.S.T. principles: Fast, Isolated, Repeatable, Self-validating, Timely
+3. USE patterns: Page Object Model, Builder pattern, Factory pattern
+4. INTEGRATE in CI/CD: Every commit runs tests, fail fast, clear feedback
+5. MANAGE flaky tests: Quarantine, fix, or delete - never ignore
+
+**Quick Anti-Pattern Detection:**
+- Ice cream cone (many E2E, few unit) → Invert to pyramid
+- Slow tests (> 10 min suite) → Parallelize, mock external deps
+- Flaky tests → Fix timing, isolate data, or quarantine
+- Test duplication → Share fixtures, use page objects
+- Brittle selectors → Use data-testid, semantic locators
+
+**Critical Success Factors:**
+- Fast feedback is the goal (< 10 min full suite)
+- Automation supports testing, doesn't replace judgment
+- Invest in test infrastructure like production code
+</default_to_action>
+
+## Quick Reference Card
+
+### When to Use
+- Building new automation framework
+- Improving existing test efficiency
+- Reducing flaky test burden
+- Optimizing CI/CD pipeline speed
+
+### Test Pyramid
+| Layer | % | Speed | Isolation | Examples |
+|-------|---|-------|-----------|----------|
+| **Unit** | 70% | < 1ms | Complete | Pure functions, logic |
+| **Integration** | 20% | < 1s | Partial | API, database |
+| **E2E** | 10% | < 30s | None | User journeys |
+
+### F.I.R.S.T. Principles
+| Principle | Meaning | How |
+|-----------|---------|-----|
+| **F**ast | Quick execution | Mock external deps |
+| **I**solated | No shared state | Fresh fixtures per test |
+| **R**epeatable | Same result every time | No random data |
+| **S**elf-validating | Clear pass/fail | Assert, don't print |
+| **T**imely | Written with code | TDD, not after |
+
+### Anti-Patterns
+| Problem | Symptom | Fix |
+|---------|---------|-----|
+| Ice cream cone | 80% E2E, 10% unit | Invert pyramid |
+| Slow suite | 30+ min CI | Parallelize, prune |
+| Flaky tests | Random failures | Quarantine, fix timing |
+| Coupled tests | Order-dependent | Isolate data |
+| Brittle selectors | Break on CSS change | Use data-testid |
+
+---
+
+## Page Object Model
+
+```javascript
+// pages/LoginPage.js
+class LoginPage {
+  constructor(page) {
+    this.page = page;
+    this.emailInput = '[data-testid="email"]';
+    this.passwordInput = '[data-testid="password"]';
+    this.submitButton = '[data-testid="submit"]';
+    this.errorMessage = '[data-testid="error"]';
+  }
+
+  async login(email, password) {
+    await this.page.fill(this.emailInput, email);
+    await this.page.fill(this.passwordInput, password);
+    await this.page.click(this.submitButton);
+  }
+
+  async getError() {
+    return this.page.textContent(this.errorMessage);
+  }
+}
+
+// Test uses page object
+test('shows error for invalid credentials', async ({ page }) => {
+  const loginPage = new LoginPage(page);
+  await loginPage.login('bad@email.com', 'wrong');
+  expect(await loginPage.getError()).toBe('Invalid credentials');
+});
+```
+
+---
+
+## CI/CD Integration
+
+```yaml
+name: Test Pipeline
+on: [push, pull_request]
+
+jobs:
+  unit-tests:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - run: npm ci
+      - run: npm run test:unit -- --coverage
+        timeout-minutes: 5
+      - uses: codecov/codecov-action@v3
+
+  integration-tests:
+    needs: unit-tests
+    runs-on: ubuntu-latest
+    services:
+      postgres:
+        image: postgres:15
+    steps:
+      - run: npm run test:integration
+        timeout-minutes: 10
+
+  e2e-tests:
+    needs: integration-tests
+    runs-on: ubuntu-latest
+    steps:
+      - run: npx playwright test
+        timeout-minutes: 15
+```
+
+---
+
+## Flaky Test Management
+
+```typescript
+// Quarantine flaky tests
+describe.skip('Quarantined - INC-123', () => {
+  test('flaky test awaiting fix', () => { /* ... */ });
+});
+
+// Agent-assisted stabilization
+await Task("Fix Flaky Tests", {
+  tests: quarantinedTests,
+  analysis: ['timing-issues', 'data-isolation', 'race-conditions'],
+  strategies: ['add-waits', 'isolate-fixtures', 'mock-externals']
+}, "qe-flaky-test-hunter");
+```
+
+---
+
+## Agent-Assisted Automation
+
+```typescript
+// Generate tests following pyramid
+await Task("Generate Test Suite", {
+  sourceCode: 'src/',
+  pyramid: { unit: 70, integration: 20, e2e: 10 },
+  patterns: ['page-object', 'builder', 'factory'],
+  framework: 'jest'
+}, "qe-test-generator");
+
+// Optimize test execution
+await Task("Optimize Suite", {
+  algorithm: 'johnson-lindenstrauss',
+  targetReduction: 0.3,
+  maintainCoverage: 0.95
+}, "qe-regression-risk-analyzer");
+
+// Analyze flaky patterns
+await Task("Flaky Analysis", {
+  testHistory: 'last-30-days',
+  detectPatterns: ['timing', 'data', 'environment'],
+  recommend: 'stabilization-strategy'
+}, "qe-flaky-test-hunter");
+```
+
+---
+
+## Agent Coordination Hints
+
+### Memory Namespace
+```
+aqe/automation/
+├── test-pyramid/*        - Coverage by layer
+├── page-objects/*        - Shared page objects
+├── flaky-registry/*      - Quarantined tests
+└── execution-metrics/*   - Suite performance data
+```
+
+### Fleet Coordination
+```typescript
+const automationFleet = await FleetManager.coordinate({
+  strategy: 'test-automation',
+  agents: [
+    'qe-test-generator',         // Generate pyramid-compliant tests
+    'qe-test-executor',          // Parallel execution
+    'qe-coverage-analyzer',      // Coverage gaps
+    'qe-flaky-test-hunter',      // Flaky detection
+    'qe-regression-risk-analyzer' // Smart selection
+  ],
+  topology: 'hierarchical'
+});
+```
+
+---
+
+## Related Skills
+- [tdd-london-chicago](../tdd-london-chicago/) - TDD for unit tests
+- [api-testing-patterns](../api-testing-patterns/) - Integration patterns
+- [cicd-pipeline-qe-orchestrator](../cicd-pipeline-qe-orchestrator/) - Pipeline integration
+- [shift-left-testing](../shift-left-testing/) - Early automation
+
+---
+
+## Remember
+
+**Pyramid: 70% unit, 20% integration, 10% E2E.** F.I.R.S.T. principles for every test. Page Object Model for E2E. Parallelize for speed. Quarantine flaky tests - never ignore them. Treat test code like production code.
+
+**With Agents:** Agents generate pyramid-compliant tests, detect flaky patterns, optimize execution time, and maintain test infrastructure. Use agents to scale automation quality.

package/assets/skills/test-data-management/SKILL.md

@@ -0,0 +1,270 @@
+---
+name: test-data-management
+description: "Strategic test data generation, management, and privacy compliance. Use when creating test data, handling PII, ensuring GDPR/CCPA compliance, or scaling data generation for realistic testing scenarios."
+category: specialized-testing
+priority: high
+tokenEstimate: 1000
+agents: [qe-test-data-architect, qe-test-executor, qe-security-scanner]
+implementation_status: optimized
+optimization_version: 1.0
+last_optimized: 2025-12-02
+dependencies: []
+quick_reference_card: true
+tags: [test-data, faker, synthetic, gdpr, pii, anonymization, factories]
+---
+
+# Test Data Management
+
+<default_to_action>
+When creating or managing test data:
+1. NEVER use production PII directly
+2. GENERATE synthetic data with faker libraries
+3. ANONYMIZE production data if used (mask, hash)
+4. ISOLATE test data (transactions, per-test cleanup)
+5. SCALE with batch generation (10k+ records/sec)
+
+**Quick Data Strategy:**
+- Unit tests: Minimal data (just enough)
+- Integration: Realistic data (full complexity)
+- Performance: Volume data (10k+ records)
+
+**Critical Success Factors:**
+- 40% of test failures from inadequate data
+- GDPR fines up to €20M for PII violations
+- Never store production PII in test environments
+</default_to_action>
+
+## Quick Reference Card
+
+### When to Use
+- Creating test datasets
+- Handling sensitive data
+- Performance testing with volume
+- GDPR/CCPA compliance
+
+### Data Strategies
+| Type | When | Size |
+|------|------|------|
+| **Minimal** | Unit tests | 1-10 records |
+| **Realistic** | Integration | 100-1000 records |
+| **Volume** | Performance | 10k+ records |
+| **Edge cases** | Boundary testing | Targeted |
+
+### Privacy Techniques
+| Technique | Use Case |
+|-----------|----------|
+| **Synthetic** | Generate fake data (preferred) |
+| **Masking** | j***@example.com |
+| **Hashing** | Irreversible pseudonymization |
+| **Tokenization** | Reversible with key |
+
+---
+
+## Synthetic Data Generation
+
+```javascript
+import { faker } from '@faker-js/faker';
+
+// Seed for reproducibility
+faker.seed(123);
+
+function generateUser() {
+  return {
+    id: faker.string.uuid(),
+    email: faker.internet.email(),
+    firstName: faker.person.firstName(),
+    lastName: faker.person.lastName(),
+    phone: faker.phone.number(),
+    address: {
+      street: faker.location.streetAddress(),
+      city: faker.location.city(),
+      zip: faker.location.zipCode()
+    },
+    createdAt: faker.date.past()
+  };
+}
+
+// Generate 1000 users
+const users = Array.from({ length: 1000 }, generateUser);
+```
+
+---
+
+## Test Data Builder Pattern
+
+```typescript
+class UserBuilder {
+  private user: Partial<User> = {};
+
+  asAdmin() {
+    this.user.role = 'admin';
+    this.user.permissions = ['read', 'write', 'delete'];
+    return this;
+  }
+
+  asCustomer() {
+    this.user.role = 'customer';
+    this.user.permissions = ['read'];
+    return this;
+  }
+
+  withEmail(email: string) {
+    this.user.email = email;
+    return this;
+  }
+
+  build(): User {
+    return {
+      id: this.user.id ?? faker.string.uuid(),
+      email: this.user.email ?? faker.internet.email(),
+      role: this.user.role ?? 'customer',
+      ...this.user
+    } as User;
+  }
+}
+
+// Usage
+const admin = new UserBuilder().asAdmin().withEmail('admin@test.com').build();
+const customer = new UserBuilder().asCustomer().build();
+```
+
+---
+
+## Data Anonymization
+
+```javascript
+// Masking
+function maskEmail(email) {
+  const [user, domain] = email.split('@');
+  return `${user[0]}***@${domain}`;
+}
+// john@example.com → j***@example.com
+
+function maskCreditCard(cc) {
+  return `****-****-****-${cc.slice(-4)}`;
+}
+// 4242424242424242 → ****-****-****-4242
+
+// Anonymize production data
+const anonymizedUsers = prodUsers.map(user => ({
+  id: user.id, // Keep ID for relationships
+  email: `user-${user.id}@example.com`, // Fake email
+  firstName: faker.person.firstName(), // Generated
+  phone: null, // Remove PII
+  createdAt: user.createdAt // Keep non-PII
+}));
+```
+
+---
+
+## Database Transaction Isolation
+
+```javascript
+// Best practice: use transactions for cleanup
+beforeEach(async () => {
+  await db.beginTransaction();
+});
+
+afterEach(async () => {
+  await db.rollbackTransaction(); // Auto cleanup!
+});
+
+test('user registration', async () => {
+  const user = await userService.register({
+    email: 'test@example.com'
+  });
+  expect(user.id).toBeDefined();
+  // Automatic rollback after test - no cleanup needed
+});
+```
+
+---
+
+## Volume Data Generation
+
+```javascript
+// Generate 10,000 users efficiently
+async function generateLargeDataset(count = 10000) {
+  const batchSize = 1000;
+  const batches = Math.ceil(count / batchSize);
+
+  for (let i = 0; i < batches; i++) {
+    const users = Array.from({ length: batchSize }, (_, index) => ({
+      id: i * batchSize + index,
+      email: `user${i * batchSize + index}@example.com`,
+      firstName: faker.person.firstName()
+    }));
+
+    await db.users.insertMany(users); // Batch insert
+    console.log(`Batch ${i + 1}/${batches}`);
+  }
+}
+```
+
+---
+
+## Agent-Driven Data Generation
+
+```typescript
+// High-speed generation with constraints
+await Task("Generate Test Data", {
+  schema: 'ecommerce',
+  count: { users: 10000, products: 500, orders: 5000 },
+  preserveReferentialIntegrity: true,
+  constraints: {
+    age: { min: 18, max: 90 },
+    roles: ['customer', 'admin']
+  }
+}, "qe-test-data-architect");
+
+// GDPR-compliant anonymization
+await Task("Anonymize Production Data", {
+  source: 'production-snapshot',
+  piiFields: ['email', 'phone', 'ssn'],
+  method: 'pseudonymization',
+  retainStructure: true
+}, "qe-test-data-architect");
+```
+
+---
+
+## Agent Coordination Hints
+
+### Memory Namespace
+```
+aqe/test-data-management/
+├── schemas/*            - Data schemas
+├── generators/*         - Generator configs
+├── anonymization/*      - PII handling rules
+└── fixtures/*           - Reusable fixtures
+```
+
+### Fleet Coordination
+```typescript
+const dataFleet = await FleetManager.coordinate({
+  strategy: 'test-data-generation',
+  agents: [
+    'qe-test-data-architect',  // Generate data
+    'qe-test-executor',        // Execute with data
+    'qe-security-scanner'      // Validate no PII exposure
+  ],
+  topology: 'sequential'
+});
+```
+
+---
+
+## Related Skills
+- [database-testing](../database-testing/) - Schema and integrity testing
+- [compliance-testing](../compliance-testing/) - GDPR/CCPA compliance
+- [performance-testing](../performance-testing/) - Volume data for perf tests
+
+---
+
+## Remember
+
+**Test data is infrastructure, not an afterthought.** 40% of test failures are caused by inadequate test data. Poor data = poor tests.
+
+**Never use production PII directly.** GDPR fines up to €20M or 4% of revenue. Always use synthetic data or properly anonymized production snapshots.
+
+**With Agents:** `qe-test-data-architect` generates 10k+ records/sec with realistic patterns, relationships, and constraints. Agents ensure GDPR/CCPA compliance automatically and eliminate test data bottlenecks.