Smart Test Data Generation Using AI: A Practical Guide

import Anthropic from '@anthropic-ai/sdk';
 
const anthropic = new Anthropic();
 
async function generateUserTestData(count: number): Promise<User[]> {
  const response = await anthropic.messages.create({
    model: 'claude-sonnet-4-20250514',
    max_tokens: 2000,
    messages: [{
      role: 'user',
      content: `Generate ${count} realistic but fictional user records for testing an e-commerce platform.
      
      Include diversity in:
      - Names (international, unusual characters, hyphenated, single names, very long names)
      - Email formats (subaddressing like user+tag@domain.com, different TLDs, edge cases)
      - Phone numbers (different countries, formats, with/without country codes)
      - Addresses (international, PO boxes, apartment formats, missing fields)
      
      Also include these specific edge cases:
      - A user with a name containing SQL injection attempt
      - A user with emoji in their display name
      - A user with maximum-length fields
      - A user with minimal required fields only
      
      Return ONLY a valid JSON array, no markdown, no explanation.
      Each object: { id, firstName, lastName, email, phone, address, createdAt }`
    }]
  });
 
  const text = response.content[0].type === 'text' ? response.content[0].text : '';
  return JSON.parse(text);
}

async function generateEmailEdgeCases(): Promise<string[]> {
  const response = await anthropic.messages.create({
    model: 'claude-sonnet-4-20250514',
    max_tokens: 1000,
    messages: [{
      role: 'user',
      content: `Generate a comprehensive list of email address edge cases for testing an email validation system.
      
      Include:
      - Valid emails that naive validators reject (valid per RFC 5321)
      - Invalid emails that naive validators accept  
      - Internationalized domain names
      - Subaddressing (user+tag@domain.com)
      - IP address domains
      - Very long local parts
      - Unicode in local part
      - Common typos (gmail.com → gmial.com)
      - Disposable email domains
      - Business email patterns
      
      Return ONLY a JSON array of strings. No explanation.`
    }]
  });
 
  return JSON.parse(response.content[0].type === 'text' ? response.content[0].text : '[]');
}

async function generateProductCatalogData() {
  const response = await anthropic.messages.create({
    model: 'claude-sonnet-4-20250514',
    max_tokens: 3000,
    messages: [{
      role: 'user',
      content: `Generate test product data for an e-commerce platform. Include edge cases that test:
      
      1. Pricing edge cases: $0.00 products, very high prices ($99,999.99), prices with many decimal places
      2. Inventory edge cases: 0 stock, negative stock (pre-order), very large inventory (10000+)  
      3. Name edge cases: very short (1 char), very long (200+ chars), special characters, unicode
      4. Category edge cases: uncategorised products, multi-category products
      5. Image edge cases: no image, multiple images, broken image URL
      6. Description edge cases: empty, very long (5000+ chars), HTML in description
      
      Return ONLY valid JSON array. Schema: { id, name, price, stock, category, description, imageUrl }`
    }]
  });
 
  return JSON.parse(response.content[0].type === 'text' ? response.content[0].text : '[]');
}

import { faker } from '@faker-js/faker';
 
// Faker for volume data
function generateBulkUsers(count: number) {
  return Array.from({ length: count }, () => ({
    id: faker.string.uuid(),
    name: faker.person.fullName(),
    email: faker.internet.email(),
    phone: faker.phone.number(),
    address: faker.location.streetAddress(),
  }));
}
 
// LLM for targeted edge cases — combine both
async function generateCompleteTestDataset(bulkCount: number) {
  const bulkData = generateBulkUsers(bulkCount);
  const edgeCases = await generateUserTestData(20); // LLM-generated edge cases
  
  return [...bulkData, ...edgeCases];
}

# Example: anonymise a production user sample
import anthropic
 
def anonymise_user_sample(production_users: list) -> list:
    """
    Takes real user records and generates synthetic equivalents
    with similar patterns but no real PII.
    """
    client = anthropic.Anthropic()
    
    # Extract just the structure (no actual data) to show the LLM
    sample = production_users[:3]  # Small sample for pattern recognition
    
    response = client.messages.create(
        model="claude-sonnet-4-20250514",
        max_tokens=3000,
        messages=[{
            "role": "user",
            "content": f"""Given this sample of user records (patterns only, ignore the actual values):
            {sample}
            
            Generate {len(production_users)} synthetic user records that:
            - Follow the same patterns and formats as the sample
            - Contain ONLY fictional names, emails, addresses (no real people)
            - Maintain similar data distributions (name length, email domain distribution, etc.)
            - Include the same fields as the original
            
            Return ONLY a JSON array. No explanation."""
        }]
    )
    
    return json.loads(response.content[0].text)

// test/factories/dataFactory.ts
export class DataFactory {
  private aiClient: Anthropic;
  
  constructor() {
    this.aiClient = new Anthropic();
  }
  
  // Fast: Faker for standard data
  user(overrides: Partial<User> = {}): User {
    return {
      id: faker.string.uuid(),
      email: faker.internet.email(),
      name: faker.person.fullName(),
      ...overrides,
    };
  }
  
  // AI-powered: for edge case coverage
  async userEdgeCases(): Promise<User[]> {
    const cacheKey = 'user-edge-cases';
    // Cache AI-generated data between test runs to avoid repeated API calls
    if (this.cache.has(cacheKey)) return this.cache.get(cacheKey);
    
    const data = await this.generateWithAI('users', 20);
    this.cache.set(cacheKey, data);
    return data;
  }
}