agentic-qe 2.0.0 → 2.1.1

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

@@ -1,36 +1,70 @@
 ---
 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.
+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
 
-## Core Principle
+<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 |
 
-**Data is your most valuable asset. Database bugs cause data loss/corruption.**
-
-Database testing ensures schema correctness, data integrity, transaction safety, and query performance. Critical for preventing catastrophic data issues.
+---
 
 ## Schema Testing
 
-**Validate database structure:**
-```sql
--- Test schema exists
-SELECT table_name FROM information_schema.tables 
-WHERE table_schema = 'public' AND table_name = 'users';
-
--- Test column types
-SELECT column_name, data_type 
-FROM information_schema.columns 
-WHERE table_name = 'users';
-
--- Test constraints
-SELECT constraint_name, constraint_type
-FROM information_schema.table_constraints
-WHERE table_name = 'users';
-```
-
-**Test with code:**
 ```javascript
 test('users table has correct schema', async () => {
   const schema = await db.raw(`
@@ -53,14 +87,14 @@ test('users table has correct schema', async () => {
 });
 ```
 
+---
+
 ## Data Integrity Testing
 
-**Test constraints:**
 ```javascript
 test('email must be unique', async () => {
   await db.users.create({ email: 'test@example.com' });
 
-  // Duplicate should fail
   await expect(
     db.users.create({ email: 'test@example.com' })
   ).rejects.toThrow('unique constraint violation');
@@ -70,72 +104,46 @@ 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 });
 
-  // Cannot delete user with orders
   await expect(
     db.users.delete({ id: user.id })
   ).rejects.toThrow('foreign key constraint');
 });
-
-test('check constraint validates data', async () => {
-  // Age must be ≥ 18
-  await expect(
-    db.users.create({ email: 'minor@example.com', age: 17 })
-  ).rejects.toThrow('check constraint violation');
-});
 ```
 
+---
+
 ## Migration Testing
 
-**Test database migrations:**
 ```javascript
-import { migrate, rollback } from './migrations';
-
-test('migration adds users table', async () => {
-  // Start fresh
-  await rollback();
-
-  // Run migration
-  await migrate();
-
-  // Verify table exists
-  const tables = await db.raw(`
-    SELECT table_name FROM information_schema.tables
-    WHERE table_schema = 'public'
-  `);
+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');
-});
 
-test('migration is reversible', async () => {
-  await migrate();
-  await rollback();
+  await rollback('add-users-table');
 
-  // Table should be gone
-  const tables = await db.raw(`
-    SELECT table_name FROM information_schema.tables
-    WHERE table_schema = 'public'
-  `);
-
-  expect(tables.map(t => t.table_name)).not.toContain('users');
+  // 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 () => {
-  // Create data before migration
   await db.users.create({ email: 'test@example.com' });
 
-  // Run migration that adds 'age' column
   await migrate('add-age-column');
 
-  // Data should still exist
   const user = await db.users.findOne({ email: 'test@example.com' });
   expect(user).toBeDefined();
   expect(user.age).toBeNull(); // New column, null default
 });
 ```
 
-## Transaction Isolation Testing
+---
+
+## Transaction Testing
 
-**Test ACID properties:**
 ```javascript
 test('transaction rolls back on error', async () => {
   const initialCount = await db.users.count();
@@ -144,94 +152,93 @@ test('transaction rolls back on error', async () => {
     await db.transaction(async (trx) => {
       await trx('users').insert({ email: 'user1@example.com' });
       await trx('users').insert({ email: 'user2@example.com' });
-
-      // Force error
       throw new Error('Rollback test');
     });
-  } catch (error) {
-    // Expected
-  }
+  } catch (error) { /* Expected */ }
 
-  // No users should be inserted
-  const finalCount = await db.users.count();
-  expect(finalCount).toBe(initialCount);
+  expect(await db.users.count()).toBe(initialCount);
 });
 
-test('concurrent transactions are isolated', async () => {
-  const user = await db.users.create({ email: 'test@example.com', balance: 100 });
-
-  // Two concurrent withdrawals
-  const withdraw1 = db.transaction(async (trx) => {
-    const current = await trx('users').where({ id: user.id }).first();
-    await sleep(100); // Simulate delay
-    await trx('users').where({ id: user.id }).update({ 
-      balance: current.balance - 50 
-    });
-  });
+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 withdraw2 = db.transaction(async (trx) => {
-    const current = await trx('users').where({ id: user.id }).first();
-    await sleep(100);
-    await trx('users').where({ id: user.id }).update({ 
-      balance: current.balance - 50 
-    });
-  });
-
-  await Promise.all([withdraw1, withdraw2]);
-
-  // With proper isolation, balance should be 0, not 50
   const final = await db.users.findOne({ id: user.id });
-  expect(final.balance).toBe(0); // Not 50!
+  expect(final.balance).toBe(0); // Proper isolation
 });
 ```
 
-## Query Performance Testing
+---
 
-**Test slow queries:**
-```javascript
-test('user lookup by email is fast', async () => {
-  // Seed 10,000 users
-  await seedUsers(10000);
+## 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");
+```
 
-  const start = Date.now();
-  await db.users.findOne({ email: 'user5000@example.com' });
-  const duration = Date.now() - start;
+---
 
-  // Should use index on email
-  expect(duration).toBeLessThan(10); // < 10ms
-});
+## Agent Coordination Hints
 
-test('EXPLAIN shows index usage', async () => {
-  const explain = await db.raw(`
-    EXPLAIN SELECT * FROM users WHERE email = 'test@example.com'
-  `);
+### Memory Namespace
+```
+aqe/database-testing/
+├── schema-snapshots/*   - Current schema state
+├── migrations/*         - Migration test results
+├── integrity/*          - Constraint validation
+└── performance/*        - Query benchmarks
+```
 
-  // Should show index scan, not sequential scan
-  const plan = explain.rows[0]['QUERY PLAN'];
-  expect(plan).toContain('Index Scan');
-  expect(plan).not.toContain('Seq Scan');
+### 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
 
-- [test-data-management](../test-data-management/) - Generate test data for DB
-- [performance-testing](../performance-testing/) - DB performance testing
-- [test-automation-strategy](../test-automation-strategy/) - Automate DB tests
+---
 
 ## Remember
 
-**Database bugs are catastrophic.**
-
-- Data loss is unrecoverable
-- Corruption spreads silently
-- Performance issues compound
-- Migrations must be reversible
+**Database bugs are catastrophic.** Data loss is unrecoverable. Corruption spreads silently. Performance issues compound.
 
-**Test migrations before production:**
-- Forward migration works
-- Backward rollback works
-- Data preserved/migrated correctly
-- Performance acceptable
+**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` runs DB migration tests automatically in CI/CD.
+**With Agents:** `qe-test-data-architect` generates realistic test data with referential integrity. `qe-test-executor` validates migrations automatically in CI/CD.