Test Generation Chains

Tests validate that generated code works correctly. This lesson covers workflows for generating comprehensive test suites.

The Test Generation Pipeline

Code Analysis → Test Cases → Test Code → Validation → Coverage Check

Test Case Generation

From Code to Test Cases

Categorizing Test Types

const testCategories = {
  unit: {
    description: 'Test individual functions in isolation',
    mocking: 'Mock all dependencies',
    scope: 'Single function/method'
  },
  integration: {
    description: 'Test component interactions',
    mocking: 'Mock external services only',
    scope: 'Multiple components working together'
  },
  e2e: {
    description: 'Test complete user flows',
    mocking: 'Minimal mocking',
    scope: 'Full system behavior'
  }
};

Test Code Generation

From Cases to Code

async function generateTestCode(testCases, codeToTest, framework = 'jest') {
  const prompt = `
Generate ${framework} test code for these test cases.

CODE UNDER TEST:
${codeToTest}

TEST CASES:
${JSON.stringify(testCases, null, 2)}

Requirements:
1. Use describe/it blocks for organization
2. Use meaningful assertion messages
3. Group related tests
4. Include setup/teardown if needed
5. Follow ${framework} best practices

Generate the complete test file:
`;

  return await llm.chat({ content: prompt });
}

Test Template Generation

Coverage Analysis

Identifying Coverage Gaps

async function analyzeCoverage(code, existingTests) {
  const prompt = `
Analyze test coverage and identify gaps.

CODE:
${code}

EXISTING TESTS:
${existingTests}

Analyze:
1. Which code paths are tested?
2. Which are NOT tested?
3. Which edge cases are missing?
4. Which error scenarios are untested?

Return:
{
  "covered": ["list of tested scenarios"],
  "gaps": [
    {
      "description": "what's not tested",
      "severity": "high|medium|low",
      "suggested_test": "test case description"
    }
  ],
  "coverage_estimate": "percentage"
}
`;

  return await llm.chat({ content: prompt });
}

Generating Missing Tests

async function generateMissingTests(coverageGaps, code) {
  const newTests = [];

  for (const gap of coverageGaps.filter(g => g.severity === 'high')) {
    const test = await generateTestForGap(gap, code);
    newTests.push(test);
  }

  return newTests;
}

Test Quality Validation

Verifying Test Correctness

Test Smell Detection

const testSmells = [
  {
    name: 'Magic Numbers',
    pattern: /expect\(.+\)\.toBe\(\d+\)/,
    fix: 'Use named constants'
  },
  {
    name: 'No Assertions',
    pattern: /it\([^)]+,\s*\(\)\s*=>\s*\{[^}]*\}\)/,
    fix: 'Add expect statements'
  },
  {
    name: 'Too Many Assertions',
    check: (test) => (test.match(/expect/g) || []).length > 5,
    fix: 'Split into multiple tests'
  },
  {
    name: 'Implementation Testing',
    pattern: /toHaveBeenCalledWith.*internal/i,
    fix: 'Test behavior, not implementation'
  }
];

Complete Test Generation Chain

async function testGenerationChain(code) {
  // Step 1: Analyze code structure
  const analysis = await analyzeCode(code);

  // Step 2: Generate test cases
  const testCases = await generateTestCases(code, analysis);

  // Step 3: Generate test code
  const testCode = await generateTestCode(testCases, code);

  // Step 4: Validate tests
  const validation = await validateTests(testCode, code);

  // Step 5: Check coverage
  const coverage = await analyzeCoverage(code, testCode);

  // Step 6: Generate missing tests
  if (coverage.gaps.length > 0) {
    const additionalTests = await generateMissingTests(coverage.gaps, code);
    testCode.push(...additionalTests);
  }

  return {
    testCases,
    testCode,
    coverage,
    validation
  };
}

Exercise: Build a Test Generation Chain

Key Takeaways

• Analyze code structure before generating tests
• Generate test cases first, then test code
• Cover happy paths, edge cases, and errors
• Validate generated tests for correctness
• Check coverage and fill gaps
• Detect and fix test smells
• Use appropriate test frameworks and conventions

Next, we'll cover code review and refactoring chains.