@agentic-qe/v3 3.0.0-alpha.6 → 3.0.0-alpha.7

package/assets/skills/database-testing/SKILL.md

@@ -0,0 +1,244 @@
+---
+name: database-testing
+description: "Database schema validation, data integrity testing, migration testing, transaction isolation, and query performance. Use when testing data persistence, ensuring referential integrity, or validating database migrations."
+category: specialized-testing
+priority: high
+tokenEstimate: 900
+agents: [qe-test-data-architect, qe-test-executor, qe-performance-tester]
+implementation_status: optimized
+optimization_version: 1.0
+last_optimized: 2025-12-02
+dependencies: []
+quick_reference_card: true
+tags: [database, schema, migration, transactions, integrity, sql, performance]
+---
+
+# Database Testing
+
+<default_to_action>
+When testing database operations:
+1. VALIDATE schema (tables, columns, constraints exist as expected)
+2. TEST data integrity (unique, foreign key, check constraints)
+3. VERIFY migrations (forward works, rollback works, data preserved)
+4. CHECK transaction isolation (ACID properties, concurrent access)
+5. MEASURE query performance (indexes used, execution time)
+
+**Quick DB Testing Checklist:**
+- Schema matches specification
+- Unique constraints prevent duplicates
+- Foreign keys prevent orphaned records
+- Migrations are reversible
+- Transactions roll back on error
+
+**Critical Success Factors:**
+- Database bugs cause data loss/corruption (catastrophic)
+- Test migrations in staging before production
+- Transaction tests catch concurrency bugs
+</default_to_action>
+
+## Quick Reference Card
+
+### When to Use
+- New table/schema creation
+- Migration development
+- Data integrity validation
+- Query performance optimization
+
+### Database Test Types
+| Type | Focus | When |
+|------|-------|------|
+| **Schema** | Structure correct | Table creation |
+| **Integrity** | Constraints work | Data operations |
+| **Migration** | Up/down work | Schema changes |
+| **Transaction** | ACID properties | Concurrent access |
+| **Performance** | Query speed | Optimization |
+
+### ACID Properties
+| Property | Test Focus |
+|----------|------------|
+| **Atomicity** | All or nothing (rollback on error) |
+| **Consistency** | Constraints always valid |
+| **Isolation** | Concurrent transactions don't interfere |
+| **Durability** | Committed data persists |
+
+---
+
+## Schema Testing
+
+```javascript
+test('users table has correct schema', async () => {
+  const schema = await db.raw(`
+    SELECT column_name, data_type, is_nullable
+    FROM information_schema.columns
+    WHERE table_name = 'users'
+  `);
+
+  expect(schema).toContainEqual({
+    column_name: 'id',
+    data_type: 'integer',
+    is_nullable: 'NO'
+  });
+
+  expect(schema).toContainEqual({
+    column_name: 'email',
+    data_type: 'character varying',
+    is_nullable: 'NO'
+  });
+});
+```
+
+---
+
+## Data Integrity Testing
+
+```javascript
+test('email must be unique', async () => {
+  await db.users.create({ email: 'test@example.com' });
+
+  await expect(
+    db.users.create({ email: 'test@example.com' })
+  ).rejects.toThrow('unique constraint violation');
+});
+
+test('foreign key prevents orphaned records', async () => {
+  const user = await db.users.create({ email: 'test@example.com' });
+  await db.orders.create({ userId: user.id, total: 100 });
+
+  await expect(
+    db.users.delete({ id: user.id })
+  ).rejects.toThrow('foreign key constraint');
+});
+```
+
+---
+
+## Migration Testing
+
+```javascript
+test('migration is reversible', async () => {
+  await migrate('add-users-table');
+
+  // Table exists after migration
+  const tables = await db.raw(`SELECT table_name FROM information_schema.tables`);
+  expect(tables.map(t => t.table_name)).toContain('users');
+
+  await rollback('add-users-table');
+
+  // Table gone after rollback
+  const tablesAfter = await db.raw(`SELECT table_name FROM information_schema.tables`);
+  expect(tablesAfter.map(t => t.table_name)).not.toContain('users');
+});
+
+test('migration preserves existing data', async () => {
+  await db.users.create({ email: 'test@example.com' });
+
+  await migrate('add-age-column');
+
+  const user = await db.users.findOne({ email: 'test@example.com' });
+  expect(user).toBeDefined();
+  expect(user.age).toBeNull(); // New column, null default
+});
+```
+
+---
+
+## Transaction Testing
+
+```javascript
+test('transaction rolls back on error', async () => {
+  const initialCount = await db.users.count();
+
+  try {
+    await db.transaction(async (trx) => {
+      await trx('users').insert({ email: 'user1@example.com' });
+      await trx('users').insert({ email: 'user2@example.com' });
+      throw new Error('Rollback test');
+    });
+  } catch (error) { /* Expected */ }
+
+  expect(await db.users.count()).toBe(initialCount);
+});
+
+test('concurrent transactions isolated', async () => {
+  const user = await db.users.create({ balance: 100 });
+
+  // Two concurrent withdrawals (race condition test)
+  await Promise.all([
+    db.transaction(async (trx) => {
+      const current = await trx('users').where({ id: user.id }).first();
+      await trx('users').update({ balance: current.balance - 50 });
+    }),
+    db.transaction(async (trx) => {
+      const current = await trx('users').where({ id: user.id }).first();
+      await trx('users').update({ balance: current.balance - 50 });
+    })
+  ]);
+
+  const final = await db.users.findOne({ id: user.id });
+  expect(final.balance).toBe(0); // Proper isolation
+});
+```
+
+---
+
+## Agent-Driven Database Testing
+
+```typescript
+// Generate test data with integrity
+await Task("Generate Test Data", {
+  schema: 'ecommerce',
+  tables: ['users', 'products', 'orders'],
+  count: { users: 1000, products: 500, orders: 5000 },
+  preserveReferentialIntegrity: true
+}, "qe-test-data-architect");
+
+// Test migration safety
+await Task("Migration Test", {
+  migration: 'add-payment-status-column',
+  tests: ['forward', 'rollback', 'data-preservation'],
+  environment: 'staging'
+}, "qe-test-executor");
+```
+
+---
+
+## Agent Coordination Hints
+
+### Memory Namespace
+```
+aqe/database-testing/
+├── schema-snapshots/*   - Current schema state
+├── migrations/*         - Migration test results
+├── integrity/*          - Constraint validation
+└── performance/*        - Query benchmarks
+```
+
+### Fleet Coordination
+```typescript
+const dbFleet = await FleetManager.coordinate({
+  strategy: 'database-testing',
+  agents: [
+    'qe-test-data-architect',  // Generate test data
+    'qe-test-executor',        // Run DB tests
+    'qe-performance-tester'    // Query performance
+  ],
+  topology: 'sequential'
+});
+```
+
+---
+
+## Related Skills
+- [test-data-management](../test-data-management/) - Generate test data
+- [performance-testing](../performance-testing/) - Query performance
+- [compliance-testing](../compliance-testing/) - Data protection
+
+---
+
+## Remember
+
+**Database bugs are catastrophic.** Data loss is unrecoverable. Corruption spreads silently. Performance issues compound.
+
+**Test migrations before production:** Forward works, rollback works, data preserved, performance acceptable. Never deploy untested migrations.
+
+**With Agents:** `qe-test-data-architect` generates realistic test data with referential integrity. `qe-test-executor` validates migrations automatically in CI/CD.

package/assets/skills/exploratory-testing-advanced/SKILL.md

@@ -0,0 +1,201 @@
+---
+name: exploratory-testing-advanced
+description: "Advanced exploratory testing techniques with Session-Based Test Management (SBTM), RST heuristics, and test tours. Use when planning exploration sessions, investigating bugs, or discovering unknown quality risks."
+category: testing-methodologies
+priority: high
+tokenEstimate: 1000
+agents: [qe-flaky-test-hunter, qe-visual-tester, qe-quality-analyzer]
+implementation_status: optimized
+optimization_version: 1.0
+last_optimized: 2025-12-02
+dependencies: []
+quick_reference_card: true
+tags: [exploratory, sbtm, rst, heuristics, test-tours, session-based]
+---
+
+# Advanced Exploratory Testing
+
+<default_to_action>
+When exploring software or investigating quality risks:
+1. CREATE charter with mission, scope, and time-box (45-90 min)
+2. APPLY heuristics: SFDIPOT (quality criteria), FEW HICCUPPS (consistency oracles)
+3. EXPLORE systematically using test tours (Business District, Bad Neighborhood, Historical)
+4. DOCUMENT findings in real-time with notes, screenshots, evidence
+5. DEBRIEF: What learned? What's next? Share via agent memory
+
+**Quick Heuristic Selection:**
+- What to test → SFDIPOT (Structure, Function, Data, Interfaces, Platform, Operations, Time)
+- Recognize problems → FEW HICCUPPS (Familiar, Explainable, World, History, Image, Comparable, Claims, Users, Product, Purpose, Standards)
+- Navigate app → Test Tours (12 types for different exploration strategies)
+
+**Critical Success Factors:**
+- Exploration is skilled, structured thinking - not random clicking
+- Document discoveries, not pre-planned test cases
+- Pair testing reveals more than solo exploration
+</default_to_action>
+
+## Quick Reference Card
+
+### When to Use
+- Investigating new or changed features
+- Finding bugs automation misses
+- Learning unfamiliar systems
+- Risk discovery before test planning
+
+### Session Structure (SBTM)
+| Phase | Duration | Activity |
+|-------|----------|----------|
+| Charter | 5 min | Define mission, scope, focus |
+| Explore | 45-75 min | Systematic investigation |
+| Note | Continuous | Document findings real-time |
+| Debrief | 10-15 min | Summarize, prioritize, share |
+
+### SFDIPOT Heuristic (What to Test)
+| Letter | Focus | Example Questions |
+|--------|-------|------------------|
+| **S**tructure | Is it properly composed? | Code structure, UI layout, data schema |
+| **F**unction | Does it do what it should? | Core features work correctly |
+| **D**ata | Handles data correctly? | CRUD, validation, persistence |
+| **I**nterfaces | Interacts well? | APIs, UI, integrations |
+| **P**latform | Works in environment? | Browsers, OS, devices |
+| **O**perations | Can be used/managed? | Install, config, monitor |
+| **T**ime | Handles timing? | Concurrency, timeouts, scheduling |
+
+### FEW HICCUPPS Oracle (Recognize Problems)
+| Consistency With | Check |
+|-----------------|-------|
+| **F**amiliar problems | Does this look like a known bug pattern? |
+| **E**xplainable | Can behavior be explained rationally? |
+| **W**orld | Matches real-world expectations? |
+| **H**istory | Consistent with prior versions? |
+| **I**mage | Matches brand/product image? |
+| **C**omparable | Similar to competing products? |
+| **C**laims | Matches specs/docs/marketing? |
+| **U**sers | Meets user expectations? |
+| **P**urpose | Fulfills intended purpose? |
+| **S**tatements | Matches what devs said? |
+
+### Test Tours (12 Types)
+| Tour | Strategy |
+|------|----------|
+| Business District | Critical business flows |
+| Historical | Where bugs clustered before |
+| Bad Neighborhood | Known problem areas |
+| Money | Revenue-impacting features |
+| Landmark | Navigate by key features |
+| Intellectual | Complex, thinking-intensive features |
+| FedEx | Follow data through system |
+| Garbage Collector | Cleanup and edge cases |
+| Museum | Help docs and examples |
+| Rained-Out | What happens when things fail? |
+| Couch Potato | Minimal effort paths |
+| Obsessive-Compulsive | Repetitive actions |
+
+---
+
+## Session Note Template
+
+```markdown
+**Charter:** Explore [area] to discover [what] focusing on [heuristic]
+**Time-box:** 60 min | **Tester:** [name] | **Date:** [date]
+
+## Session Notes
+- [timestamp] Observation/finding
+- [timestamp] Bug: [description] - [severity]
+- [timestamp] Question: [unclear behavior]
+
+## Findings Summary
+- Bugs: X (Critical: Y, Major: Z)
+- Questions: X
+- Ideas: X
+
+## Coverage
+- Areas explored: [list]
+- Heuristics used: [SFDIPOT areas]
+- % Time on: Bug investigation 30%, Exploration 50%, Setup 20%
+
+## Next Steps
+- [ ] Deep dive on [area]
+- [ ] Follow up on question about [topic]
+```
+
+---
+
+## Agent-Assisted Exploration
+
+```typescript
+// Collaborative exploration session
+await Task("Exploratory Session", {
+  charter: 'Explore checkout flow for payment edge cases',
+  duration: '60min',
+  heuristics: ['SFDIPOT', 'FEW_HICCUPPS'],
+  tour: 'money',
+  collaboration: 'human-navigator-agent-driver'
+}, "qe-flaky-test-hunter");
+
+// Agent generates test variations while human observes
+await Task("Edge Case Generation", {
+  area: 'payment-form',
+  variations: ['boundary-values', 'invalid-inputs', 'concurrent-submits']
+}, "qe-test-generator");
+
+// Visual exploration
+await Task("Visual Exploration", {
+  tour: 'landmark',
+  focus: 'responsive-breakpoints',
+  compare: 'baseline-screenshots'
+}, "qe-visual-tester");
+```
+
+---
+
+## Agent Coordination Hints
+
+### Memory Namespace
+```
+aqe/exploratory/
+├── sessions/*           - Session notes and findings
+├── charters/*           - Reusable charter templates
+├── bug-clusters/*       - Historical bug patterns
+└── heuristic-results/*  - What heuristics revealed
+```
+
+### Fleet Coordination
+```typescript
+const exploratoryFleet = await FleetManager.coordinate({
+  strategy: 'exploratory-testing',
+  agents: [
+    'qe-flaky-test-hunter',   // Pattern recognition
+    'qe-visual-tester',       // Visual anomalies
+    'qe-quality-analyzer'     // Risk assessment
+  ],
+  topology: 'mesh'
+});
+```
+
+---
+
+## Pairing Patterns
+
+| Pattern | Human Role | Agent Role |
+|---------|------------|------------|
+| Driver-Navigator | Navigate strategy | Execute variations |
+| Strong-Style | Dictate actions | Record findings |
+| Ping-Pong | Observe one area | Explore another |
+
+---
+
+## Related Skills
+- [context-driven-testing](../context-driven-testing/) - RST foundations
+- [risk-based-testing](../risk-based-testing/) - Focus exploration on risk
+- [agentic-quality-engineering](../agentic-quality-engineering/) - Agent coordination
+
+---
+
+## Remember
+
+**Exploratory testing = simultaneous learning, test design, and test execution.**
+
+Not random clicking. Structured, skilled investigation guided by heuristics and oracles. Document discoveries in real-time. Pair testing amplifies findings.
+
+**With Agents:** Agents generate variations, recognize patterns, and maintain session notes while humans apply judgment and intuition. Combine agent thoroughness with human insight.