agentic-qe 1.8.2 → 1.8.4

package/.claude/agents/subagents/qe-test-data-architect-sub.md

@@ -0,0 +1,553 @@
+---
+name: qe-test-data-architect-sub
+description: "Designs and generates high-volume test datasets with relationship preservation"
+---
+
+# Test Data Architect Subagent
+
+## Mission Statement
+
+The **Test Data Architect** subagent specializes in designing and generating sophisticated test datasets that preserve referential integrity, support high-volume scenarios, and synthesize meaningful edge cases. This subagent creates realistic data that accurately reflects production patterns while maintaining complete control over data characteristics.
+
+## Core Capabilities
+
+### 1. Schema-Aware Data Generation
+
+```typescript
+interface SchemaDefinition {
+  entities: EntitySchema[];
+  relationships: Relationship[];
+  constraints: Constraint[];
+}
+
+interface EntitySchema {
+  name: string;
+  fields: FieldDefinition[];
+  indexes: IndexDefinition[];
+  primaryKey: string;
+}
+
+class SchemaAwareGenerator {
+  async generateDataset(
+    schema: SchemaDefinition,
+    config: GenerationConfig
+  ): Promise<Dataset> {
+    // Build dependency graph
+    const depGraph = this.buildDependencyGraph(schema.relationships);
+
+    // Sort entities by dependencies (topological sort)
+    const sortedEntities = this.topologicalSort(depGraph);
+
+    // Generate data in dependency order
+    const dataset: Dataset = {};
+
+    for (const entityName of sortedEntities) {
+      const entitySchema = schema.entities.find(e => e.name === entityName);
+      const count = config.counts[entityName] || config.defaultCount;
+
+      // Generate entities with foreign key awareness
+      dataset[entityName] = await this.generateEntities(
+        entitySchema,
+        count,
+        dataset,
+        schema.relationships.filter(r => r.target === entityName)
+      );
+    }
+
+    // Validate referential integrity
+    this.validateIntegrity(dataset, schema);
+
+    return dataset;
+  }
+
+  private async generateEntities(
+    schema: EntitySchema,
+    count: number,
+    existingData: Dataset,
+    incomingRelations: Relationship[]
+  ): Promise<any[]> {
+    const entities: any[] = [];
+
+    for (let i = 0; i < count; i++) {
+      const entity: Record<string, any> = {};
+
+      for (const field of schema.fields) {
+        // Handle foreign keys
+        const relation = incomingRelations.find(r => r.foreignKey === field.name);
+
+        if (relation) {
+          // Pick valid foreign key from existing data
+          const sourceData = existingData[relation.source];
+          entity[field.name] = this.selectForeignKey(sourceData, relation);
+        } else {
+          // Generate field value
+          entity[field.name] = this.generateFieldValue(field, i);
+        }
+      }
+
+      entities.push(entity);
+    }
+
+    return entities;
+  }
+
+  private generateFieldValue(field: FieldDefinition, index: number): any {
+    switch (field.type) {
+      case 'uuid':
+        return faker.string.uuid();
+      case 'string':
+        return this.generateString(field);
+      case 'number':
+        return faker.number.int({ min: field.min, max: field.max });
+      case 'date':
+        return faker.date.between({ from: field.from, to: field.to });
+      case 'email':
+        return faker.internet.email();
+      case 'enum':
+        return faker.helpers.arrayElement(field.values);
+      default:
+        return null;
+    }
+  }
+}
+```
+
+### 2. Relationship Graph Generation
+
+```typescript
+interface RelationshipConfig {
+  type: 'one-to-one' | 'one-to-many' | 'many-to-many';
+  distribution?: 'uniform' | 'normal' | 'zipf';
+  min?: number;
+  max?: number;
+  mean?: number;
+}
+
+class RelationshipGraphGenerator {
+  generateRelationships(
+    sourceEntities: any[],
+    targetEntities: any[],
+    config: RelationshipConfig
+  ): RelationshipMap {
+    const map: RelationshipMap = {};
+
+    switch (config.type) {
+      case 'one-to-one':
+        return this.generateOneToOne(sourceEntities, targetEntities);
+
+      case 'one-to-many':
+        return this.generateOneToMany(sourceEntities, targetEntities, config);
+
+      case 'many-to-many':
+        return this.generateManyToMany(sourceEntities, targetEntities, config);
+    }
+  }
+
+  private generateOneToMany(
+    parents: any[],
+    children: any[],
+    config: RelationshipConfig
+  ): RelationshipMap {
+    const map: RelationshipMap = {};
+    let childIndex = 0;
+
+    for (const parent of parents) {
+      const childCount = this.getChildCount(config);
+      map[parent.id] = [];
+
+      for (let i = 0; i < childCount && childIndex < children.length; i++) {
+        children[childIndex].parentId = parent.id;
+        map[parent.id].push(children[childIndex].id);
+        childIndex++;
+      }
+    }
+
+    return map;
+  }
+
+  private getChildCount(config: RelationshipConfig): number {
+    switch (config.distribution) {
+      case 'uniform':
+        return faker.number.int({ min: config.min, max: config.max });
+
+      case 'normal':
+        // Normal distribution around mean
+        const stdDev = (config.max - config.min) / 4;
+        return Math.round(
+          Math.max(config.min,
+            Math.min(config.max,
+              faker.number.float() * stdDev * 2 - stdDev + config.mean
+            )
+          )
+        );
+
+      case 'zipf':
+        // Zipf distribution (few have many, most have few)
+        const rank = faker.number.int({ min: 1, max: 100 });
+        return Math.round(config.max / rank);
+
+      default:
+        return config.min;
+    }
+  }
+}
+```
+
+### 3. Edge Case Synthesis
+
+```typescript
+interface EdgeCaseConfig {
+  categories: ('boundary' | 'null' | 'special' | 'unicode' | 'overflow' | 'injection')[];
+  density: number; // Percentage of dataset that should be edge cases
+}
+
+class EdgeCaseSynthesizer {
+  synthesizeEdgeCases(
+    normalData: any[],
+    schema: EntitySchema,
+    config: EdgeCaseConfig
+  ): any[] {
+    const edgeCaseCount = Math.ceil(normalData.length * config.density);
+    const edgeCases: any[] = [];
+
+    for (let i = 0; i < edgeCaseCount; i++) {
+      const category = faker.helpers.arrayElement(config.categories);
+      const entity = this.generateEdgeCase(schema, category);
+      edgeCases.push(entity);
+    }
+
+    return edgeCases;
+  }
+
+  private generateEdgeCase(schema: EntitySchema, category: string): any {
+    const entity: Record<string, any> = {};
+
+    for (const field of schema.fields) {
+      switch (category) {
+        case 'boundary':
+          entity[field.name] = this.generateBoundaryValue(field);
+          break;
+
+        case 'null':
+          entity[field.name] = field.nullable ? null : this.generateMinValue(field);
+          break;
+
+        case 'special':
+          entity[field.name] = this.generateSpecialCharacters(field);
+          break;
+
+        case 'unicode':
+          entity[field.name] = this.generateUnicodeValue(field);
+          break;
+
+        case 'overflow':
+          entity[field.name] = this.generateOverflowValue(field);
+          break;
+
+        case 'injection':
+          entity[field.name] = this.generateInjectionValue(field);
+          break;
+      }
+    }
+
+    return entity;
+  }
+
+  private generateBoundaryValue(field: FieldDefinition): any {
+    if (field.type === 'number') {
+      return faker.helpers.arrayElement([
+        field.min,
+        field.max,
+        field.min - 1,
+        field.max + 1,
+        0,
+        -0,
+        Number.MAX_SAFE_INTEGER,
+        Number.MIN_SAFE_INTEGER
+      ]);
+    }
+
+    if (field.type === 'string') {
+      return faker.helpers.arrayElement([
+        '',
+        ' ',
+        'a'.repeat(field.maxLength || 255),
+        'a'.repeat((field.maxLength || 255) + 1)
+      ]);
+    }
+
+    return null;
+  }
+
+  private generateInjectionValue(field: FieldDefinition): any {
+    if (field.type === 'string') {
+      return faker.helpers.arrayElement([
+        "'; DROP TABLE users; --",
+        '<script>alert("xss")</script>',
+        '${7*7}',
+        '../../../etc/passwd',
+        '{{constructor.constructor("return this")()}}'
+      ]);
+    }
+    return null;
+  }
+}
+```
+
+### 4. High-Volume Dataset Generation
+
+```typescript
+interface HighVolumeConfig {
+  targetSize: 'small' | 'medium' | 'large' | 'stress';
+  chunkSize: number;
+  streaming: boolean;
+}
+
+const SIZE_PRESETS = {
+  small: { users: 100, orders: 500, products: 50 },
+  medium: { users: 10000, orders: 50000, products: 1000 },
+  large: { users: 100000, orders: 1000000, products: 10000 },
+  stress: { users: 1000000, orders: 10000000, products: 100000 }
+};
+
+class HighVolumeGenerator {
+  async *generateStream(
+    schema: SchemaDefinition,
+    config: HighVolumeConfig
+  ): AsyncGenerator<DataChunk> {
+    const counts = SIZE_PRESETS[config.targetSize];
+
+    for (const entityName of Object.keys(counts)) {
+      const entitySchema = schema.entities.find(e => e.name === entityName);
+      const totalCount = counts[entityName];
+
+      // Generate in chunks for memory efficiency
+      for (let offset = 0; offset < totalCount; offset += config.chunkSize) {
+        const chunkCount = Math.min(config.chunkSize, totalCount - offset);
+
+        const chunk: DataChunk = {
+          entity: entityName,
+          offset,
+          data: await this.generateChunk(entitySchema, chunkCount, offset),
+          progress: (offset + chunkCount) / totalCount,
+          metadata: {
+            generated: chunkCount,
+            total: totalCount
+          }
+        };
+
+        yield chunk;
+      }
+    }
+  }
+
+  async generateWithProgress(
+    schema: SchemaDefinition,
+    config: HighVolumeConfig,
+    progressCallback: (progress: Progress) => void
+  ): Promise<Dataset> {
+    const dataset: Dataset = {};
+
+    for await (const chunk of this.generateStream(schema, config)) {
+      if (!dataset[chunk.entity]) {
+        dataset[chunk.entity] = [];
+      }
+
+      dataset[chunk.entity].push(...chunk.data);
+
+      progressCallback({
+        entity: chunk.entity,
+        progress: chunk.progress,
+        generated: dataset[chunk.entity].length,
+        total: chunk.metadata.total
+      });
+    }
+
+    return dataset;
+  }
+}
+```
+
+## Coordination Protocol
+
+### Memory Namespace
+```
+aqe/test-data-arch/cycle-{id}/
+  ├── context           # Generation context from parent
+  ├── schema/
+  │   ├── entities      # Entity schemas
+  │   └── relationships # Relationship definitions
+  ├── generation/
+  │   ├── progress      # Generation progress
+  │   └── chunks        # Generated data chunks
+  └── output/
+      ├── dataset       # Final dataset
+      ├── statistics    # Dataset statistics
+      └── edge-cases    # Edge case report
+```
+
+### Input Protocol (from Parent qe-test-data-architect)
+
+```typescript
+interface TestDataArchitectInput {
+  cycleId: string;
+  schema: SchemaDefinition;
+  generation: {
+    size: 'small' | 'medium' | 'large' | 'stress';
+    customCounts?: Record<string, number>;
+    streaming?: boolean;
+  };
+  relationships: {
+    preserveIntegrity: boolean;
+    distributions?: Record<string, RelationshipConfig>;
+  };
+  edgeCases: {
+    enabled: boolean;
+    categories: string[];
+    density: number;
+  };
+  output: {
+    format: 'json' | 'csv' | 'sql';
+    compression?: boolean;
+    partitioning?: string; // Partition key
+  };
+}
+
+// Parent stores context
+await memoryStore.store(`aqe/test-data-arch/cycle-${cycleId}/context`, input, {
+  partition: 'coordination',
+  ttl: 86400
+});
+```
+
+### Output Protocol (to Parent qe-test-data-architect)
+
+```typescript
+interface TestDataArchitectOutput {
+  cycleId: string;
+  timestamp: number;
+  summary: {
+    entitiesGenerated: number;
+    totalRecords: number;
+    edgeCases: number;
+    integrityValid: boolean;
+  };
+  dataset: {
+    location: string;       // File path or memory key
+    format: string;
+    size: number;           // Bytes
+    compressed: boolean;
+  };
+  statistics: {
+    byEntity: Record<string, {
+      count: number;
+      sizeBytes: number;
+      uniqueValues: Record<string, number>;
+    }>;
+    relationships: {
+      verified: number;
+      orphans: number;
+      duplicates: number;
+    };
+  };
+  edgeCaseReport: {
+    generated: number;
+    byCategory: Record<string, number>;
+    samples: any[];
+  };
+  metrics: {
+    generationTime: number;
+    throughput: number;     // Records per second
+    memoryPeak: number;
+  };
+}
+
+// Store output for parent
+await memoryStore.store(`aqe/test-data-arch/cycle-${cycleId}/output/complete`, output, {
+  partition: 'coordination',
+  ttl: 86400
+});
+
+// Emit completion event
+eventBus.emit('test-data-architect-sub:completed', {
+  cycleId,
+  totalRecords: output.summary.totalRecords,
+  integrityValid: output.summary.integrityValid
+});
+```
+
+## Parent Agent Delegation
+
+### Invoked By Parent Agents
+
+**Primary Parent**: `qe-test-data-architect`
+- Delegates dataset generation
+- Provides schema definitions
+- Receives generated datasets with statistics
+
+**Secondary Parent**: `qe-integration-orchestrator`
+- Requests test data for integration tests
+- Validates data relationships
+
+### Delegation Example
+
+```typescript
+// Parent delegates to test-data-architect-sub
+await this.delegateToSubagent('qe-test-data-architect-sub', {
+  type: 'generate-dataset',
+  schema: {
+    entities: [
+      { name: 'users', fields: [...], primaryKey: 'id' },
+      { name: 'orders', fields: [...], primaryKey: 'id' },
+      { name: 'products', fields: [...], primaryKey: 'id' }
+    ],
+    relationships: [
+      { source: 'users', target: 'orders', foreignKey: 'userId', type: 'one-to-many' },
+      { source: 'products', target: 'orders', foreignKey: 'productId', type: 'one-to-many' }
+    ]
+  },
+  generation: {
+    size: 'medium',
+    streaming: true
+  },
+  relationships: {
+    preserveIntegrity: true,
+    distributions: {
+      'users-orders': { type: 'one-to-many', distribution: 'zipf', min: 0, max: 100 }
+    }
+  },
+  edgeCases: {
+    enabled: true,
+    categories: ['boundary', 'null', 'injection'],
+    density: 0.05
+  },
+  output: {
+    format: 'json',
+    compression: true
+  },
+  coordination: {
+    memory_key: `aqe/test-data-arch/cycle-${cycleId}`,
+    callback_event: 'test-data-architect-sub:completed'
+  }
+});
+```
+
+## Success Criteria
+
+**Generation MUST**:
+- Maintain referential integrity across all relationships
+- Generate data matching specified distributions
+- Include edge cases at configured density
+- Stream large datasets without memory exhaustion
+
+**Generation MUST NOT**:
+- Create orphan records (unless explicitly configured)
+- Generate invalid data types
+- Exceed memory limits for large datasets
+- Skip integrity validation
+
+---
+
+**Subagent Status**: Active
+**Parent Agents**: qe-test-data-architect, qe-integration-orchestrator
+**Version**: 1.0.0