ai-test-generation-patterns

Systematic patterns for prompting AI coding agents to generate high-quality tests including prompt engineering for test creation, coverage-driven generation, mutation-aware testing, and review checklists for AI-generated test code.

Zur Installation springen

Repository: PramodDutta/qaskills
Letzte Quellaktivität: 14. April 2026 um 07:59
Erkannte Sprache von SKILL.md: Englisch
Sterne: 201
Forks: 21

Installationsoptionen

Standardmäßig ist der Prompt ausgewählt, der zuerst die Quelle prüft. Sie können zu einem direkten Befehl wechseln oder eine lokale Kopie herunterladen.

Mit Codex oder Claude installieren Kopieren Sie diesen Prompt, fügen Sie ihn in Codex, Claude oder einen anderen Assistant ein und lassen Sie die Skill-Seite prüfen und installieren.

Ein direkter Befehl überspringt den Prüf-Prompt. Prüfen Sie die Quelle, bevor Sie ihn ausführen.

npx skills add https://github.com/PramodDutta/qaskills --skill ai-test-generation-patterns

Der Befehl bleibt in einer Zeile. Scrollen Sie horizontal, um ihn vor dem Kopieren vollständig zu prüfen.

Sie bevorzugen eine lokale Kopie? Laden Sie die Dateien herunter, die SkillsMP derzeit vorliegen.

Quelldateien prüfen

Lesen Sie SKILL.md und alle von SkillsMP angezeigten Begleitdateien, bevor Sie sich für eine Installation entscheiden.

SKILL.md

Quellanweisungen · Schreibgeschützte Vorschau

Zurück zur Suche Zurück zur Installation

publish-seo-batch

Use when publishing SEO blog articles to qaskills.sh, e.g. "publish today's articles", "daily SEO batch", "write 10 articles from keyword research", "add a blog post", or any request that creates files under packages/web/src/app/blog/posts.

2026-07-16

secure-test-data-engineer

Generate test data from the schemas you already have. Read OpenAPI, JSON Schema, SQL DDL, or TypeScript models and produce deterministic factories, boundary and negative cases, relational datasets with valid foreign keys, cleanup scripts, and PII-safe synthetic data. Production records never leave the machine.

2026-07-16

ai-release-guardian

Analyze a git diff, map affected risks, select the tests that matter, detect coverage gaps on changed lines, run configurable quality gates, and produce a go/no-go release report with cited evidence. Recommends only; never merges or deploys.

2026-07-16

Alle aus diesem Repository ansehen

AI Test Generation Patterns Skill

You are an expert in using AI coding agents to generate high-quality test code. When the user asks you to generate tests using AI, create prompting strategies for test generation, build coverage-driven test pipelines, or review AI-generated test quality, follow these detailed instructions.

Core Principles

Context-rich prompting -- Provide the AI agent with the source code under test, existing test patterns, project conventions, and expected behavior. More context produces better tests.

Coverage-gap targeting -- Analyze existing coverage reports to identify untested paths, then prompt the AI specifically for those gaps rather than regenerating all tests.

Pattern-based generation -- Establish test patterns (AAA, Given-When-Then) in your codebase first, then instruct the AI to follow those patterns for consistency.

Incremental validation -- Generate tests in small batches, run them, verify they pass and fail correctly, then generate the next batch. Never generate an entire suite without validation.

Mutation-aware testing -- Use mutation testing results to identify weak test assertions and prompt the AI to strengthen them with more specific checks.

Human review gates -- Every AI-generated test must pass human review. AI excels at generating structure but can miss business logic nuances.

Prompt versioning -- Version your generation prompts alongside your code. When test patterns change, update prompts accordingly.

Project Structure

test-generation/ prompts/ unit-test-prompt.md integration-test-prompt.md e2e-test-prompt.md api-test-prompt.md edge-case-prompt.md templates/ vitest-unit.template.ts playwright-e2e.template.ts api-test.template.ts analyzers/ coverage-analyzer.ts mutation-analyzer.ts complexity-analyzer.ts generators/ prompt-builder.ts batch-generator.ts test-validator.ts review/ quality-checker.ts anti-pattern-detector.ts assertion-strength-analyzer.ts config/ generation-config.ts model-config.ts

Prompt Builder for Test Generation

// test-generation/generators/prompt-builder.ts export interface PromptContext { sourceCode: string; sourceFile: string; existingTests?: ; ?: ; ?: ; ?: ; ?: []; } { : ; : ; : ; } { (: ): { system = ; user = .(context, ); { system, user, : , }; } (: ): { system = ; user = .(context, ); { system, user, : , }; } (: ): { system = ; user = .(context, ); { system, user, : , }; } (: , : ): { prompt = ; prompt += ; prompt += ; (context.) { prompt += ; prompt += ; } (context.) { prompt += ; } (context.) { prompt += ; } (context.?.) { prompt += ; ( area context.) { prompt += ; } prompt += ; } prompt += ; prompt; } }

AI Test Generation Patterns Skill

Core Principles

Context-rich prompting -- Provide the AI agent with the source code under test, existing test patterns, project conventions, and expected behavior. More context produces better tests.

Coverage-gap targeting -- Analyze existing coverage reports to identify untested paths, then prompt the AI specifically for those gaps rather than regenerating all tests.

Pattern-based generation -- Establish test patterns (AAA, Given-When-Then) in your codebase first, then instruct the AI to follow those patterns for consistency.

Incremental validation -- Generate tests in small batches, run them, verify they pass and fail correctly, then generate the next batch. Never generate an entire suite without validation.

Mutation-aware testing -- Use mutation testing results to identify weak test assertions and prompt the AI to strengthen them with more specific checks.

Human review gates -- Every AI-generated test must pass human review. AI excels at generating structure but can miss business logic nuances.

Prompt versioning -- Version your generation prompts alongside your code. When test patterns change, update prompts accordingly.

Project Structure

Prompt Builder for Test Generation

// test-generation/analyzers/coverage-analyzer.ts import { readFileSync, existsSync } from 'fs'; import { join } from 'path'; export interface CoverageGap { file: string; uncoveredLines: number[]; uncoveredBranches: Array<{ line: number; branch: string }>; uncoveredFunctions: string[]; currentCoverage: number; targetCoverage: number; priority: 'critical' | 'high' | 'medium' | 'low'; } export class CoverageAnalyzer { analyzeCoverageReport(reportPath: string): CoverageGap[] { if (!existsSync(reportPath)) { throw new Error(`Coverage report not found: ${reportPath}`); } const report = JSON.parse(readFileSync(reportPath, 'utf-8')); const gaps: CoverageGap[] = []; for (const [file, data] of Object.entries(report) as [string, any][]) { const uncoveredLines = this.findUncoveredLines(data.s); const uncoveredBranches = this.findUncoveredBranches(data.b, data.branchMap); const uncoveredFunctions = this.findUncoveredFunctions(data.f, data.fnMap); if (uncoveredLines.length > 0 || uncoveredBranches.length > 0 || uncoveredFunctions.length > 0) { const totalStatements = Object.keys(data.s).length; const coveredStatements = Object.values(data.s as Record<string, number>).filter((v) => v > 0).length; const currentCoverage = totalStatements > 0 ? (coveredStatements / totalStatements) * 100 : 0; gaps.push({ file, uncoveredLines, uncoveredBranches, uncoveredFunctions, currentCoverage: Math.round(currentCoverage), targetCoverage: 80, priority: this.calculatePriority(file, currentCoverage, uncoveredFunctions), }); } } return gaps.sort((a, b) => { const priorityOrder = { critical: 0, high: 1, medium: 2, low: 3 }; return priorityOrder[a.priority] - priorityOrder[b.priority]; }); } buildCoveragePrompt(gap: CoverageGap): string { let prompt = `The following areas in ${gap.file} need test coverage:\n\n`; if (gap.uncoveredFunctions.length > 0) { prompt += `**Uncovered functions:**\n`; for (const fn of gap.uncoveredFunctions) { prompt += `- ${fn}\n`; } prompt += '\n'; } if (gap.uncoveredBranches.length > 0) { prompt += `**Uncovered branches:**\n`; for (const branch of gap.uncoveredBranches) { prompt += `- Line ${branch.line}: ${branch.branch}\n`; } prompt += '\n'; } if (gap.uncoveredLines.length > 0) { prompt += `**Uncovered lines:** ${gap.uncoveredLines.join(', ')}\n\n`; } prompt += `Current coverage: ${gap.currentCoverage}%. Target: ${gap.targetCoverage}%.\n`; prompt += `Focus on testing the uncovered functions and branches above.`; return prompt; } private findUncoveredLines(statements: Record<string, number>): number[] { return Object.entries(statements) .filter(([, count]) => count === 0) .map(([id]) => parseInt(id, 10)); } private findUncoveredBranches( branches: Record<string, number[]>, branchMap: Record<string, any> ): Array<{ line: number; branch: string }> { const uncovered: Array<{ line: number; branch: string }> = []; for (const [id, counts] of Object.entries(branches)) { counts.forEach((count, index) => { if (count === 0 && branchMap[id]) { uncovered.push({ line: branchMap[id].loc?.start?.line || 0, branch: `Branch ${index} of ${branchMap[id].type}`, }); } }); } return uncovered; } private findUncoveredFunctions( functions: Record<string, number>, fnMap: Record<string, any> ): string[] { return Object.entries(functions) .filter(([, count]) => count === 0) .map(([id]) => fnMap[id]?.name || `anonymous@${id}`) .filter((name) => name !== 'anonymous@undefined'); } private calculatePriority( file: string, coverage: number, uncoveredFunctions: string[] ): CoverageGap['priority'] { if (file.includes('auth') || file.includes('security') || file.includes('payment')) { return 'critical'; } if (coverage < 30) return 'high'; if (coverage < 60 || uncoveredFunctions.length > 5) return 'medium'; return 'low'; } }

// test-generation/review/quality-checker.ts export interface QualityReport { score: number; issues: QualityIssue[]; suggestions: string[]; passesReview: boolean; } export interface QualityIssue { severity: 'error' | 'warning' | 'info'; message: string; line?: number; rule: string; } export class TestQualityChecker { check(testCode: string): QualityReport { const issues: QualityIssue[] = []; const suggestions: string[] = []; // Check for common anti-patterns this.checkForEmptyTests(testCode, issues); this.checkForWeakAssertions(testCode, issues); this.checkForHardcodedValues(testCode, issues); this.checkForMissingErrorTests(testCode, issues); this.checkForProperMocking(testCode, issues); this.checkForTestIsolation(testCode, issues); this.checkForDescriptiveNames(testCode, issues); this.checkForAsyncHandling(testCode, issues); this.checkForMagicNumbers(testCode, issues); this.checkForProperCleanup(testCode, issues); // Generate suggestions if (!testCode.includes('describe(')) { suggestions.push('Group related tests in describe blocks for better organization'); } if (!testCode.includes('beforeEach') && !testCode.includes('beforeAll')) { suggestions.push('Consider using setup hooks for common test initialization'); } if ((testCode.match(/it$/g) || []).length < 3) { suggestions.push('Consider adding more test cases for better coverage'); } const errorCount = issues.filter((i) => i.severity === 'error').length; const warningCount = issues.filter((i) => i.severity === 'warning').length; const score = Math.max(0, 100 - errorCount * 20 - warningCount * 5); return { score, issues, suggestions, passesReview: score >= 60 && errorCount === 0, }; } private checkForEmptyTests(code: string, issues: QualityIssue[]): void { const emptyTestRegex = /it\([^)]+,\s*(?:async\s*)?\($\s*=>\s*\{\s*\}\)/g; const matches = code.match(emptyTestRegex); if (matches) { issues.push({ severity: 'error', message: `Found ${matches.length} empty test(s) with no assertions`, rule: 'no-empty-tests', }); } } private checkForWeakAssertions(code: string, issues: QualityIssue[]): void { const weakPatterns = [ { pattern: /expect$\w+$\.toBeTruthy/g, message: 'toBeTruthy() is too permissive - use specific assertion' }, { pattern: /expect$\w+$\.toBeDefined/g, message: 'toBeDefined() only checks not-undefined - verify actual value' }, { pattern: /expect$\w+$\.not\.toBeNull/g, message: 'not.toBeNull() is weak - assert the expected value' }, ]; for (const { pattern, message } of weakPatterns) { const matches = code.match(pattern); if (matches && matches.length > 2) { issues.push({ severity: 'warning', message: `${message} (found ${matches.length} instances)`, rule: 'strong-assertions' }); } } } private checkForHardcodedValues(code: string, issues: QualityIssue[]): void { if (code.includes('localhost:') && !code.includes('process.env')) { issues.push({ severity: 'warning', message: 'Hardcoded localhost URLs found. Use environment variables or config.', rule: 'no-hardcoded-urls', }); } } private checkForMissingErrorTests(code: string, issues: QualityIssue[]): void { const hasErrorTests = code.includes('toThrow') || code.includes('rejects') || code.includes('error') || code.includes('invalid'); if (!hasErrorTests) { issues.push({ severity: 'warning', message: 'No error handling tests found. Add tests for invalid inputs and error cases.', rule: 'error-coverage', }); } } private checkForProperMocking(code: string, issues: QualityIssue[]): void { if (code.includes('vi.fn()') || code.includes('jest.fn()')) { const mockCalls = (code.match(/vi\.fn|jest\.fn/g) || []).length; const mockVerifications = (code.match(/toHaveBeenCalled|toHaveBeenCalledWith/g) || []).length; if (mockCalls > mockVerifications * 2) { issues.push({ severity: 'warning', message: 'Mocks created but not all verified. Ensure mocks are asserted.', rule: 'verify-mocks', }); } } } private checkForTestIsolation(code: string, issues: QualityIssue[]): void { if (code.includes('let ') && !code.includes('beforeEach')) { const mutableVars = (code.match(/^\s*let\s+\w+/gm) || []).length; if (mutableVars > 2) { issues.push({ severity: 'warning', message: 'Mutable variables without beforeEach reset. Tests may not be isolated.', rule: 'test-isolation', }); } } } private checkForDescriptiveNames(code: string, issues: QualityIssue[]): void { const shortTests = code.match(/it$['"]([^'"]{1,15})['"]/g); if (shortTests && shortTests.length > 0) { issues.push({ severity: 'info', message: `${shortTests.length} test(s) have very short names. Use descriptive names explaining expected behavior.`, rule: 'descriptive-names', }); } } private checkForAsyncHandling(code: string, issues: QualityIssue[]): void { if (code.includes('Promise') || code.includes('async')) { if (!code.includes('await') && !code.includes('.resolves') && !code.includes('.rejects')) { issues.push({ severity: 'error', message: 'Async code detected but no await or promise assertions found. Tests may not wait for async operations.', rule: 'async-handling', }); } } } private checkForMagicNumbers(code: string, issues: QualityIssue[]): void { const magicNumbers = code.match(/expect\([^)]+$\.\w+$(?!['"`true|false|null|undefined|0|1|-1)\d{2,}$/g); if (magicNumbers && magicNumbers.length > 3) { issues.push({ severity: 'info', message: 'Multiple magic numbers in assertions. Consider extracting to named constants.', rule: 'no-magic-numbers', }); } } private checkForProperCleanup(code: string, issues: QualityIssue[]): void { const hasSetup = code.includes('beforeEach') || code.includes('beforeAll'); const hasCleanup = code.includes('afterEach') || code.includes('afterAll'); if (hasSetup && !hasCleanup) { issues.push({ severity: 'warning', message: 'Setup hooks found without cleanup hooks. Consider adding afterEach/afterAll for cleanup.', rule: 'proper-cleanup', }); } } }

// test-generation/generators/batch-generator.ts import Anthropic from '@anthropic-ai/sdk'; import { TestPromptBuilder, PromptContext } from './prompt-builder'; import { TestQualityChecker, QualityReport } from '../review/quality-checker'; import { readFileSync } from 'fs'; export interface BatchResult { file: string; testCode: string; quality: QualityReport; tokensUsed: number; generationTimeMs: number; } export class BatchTestGenerator { private client: Anthropic; private promptBuilder: TestPromptBuilder; private qualityChecker: TestQualityChecker; constructor() { this.client = new Anthropic(); this.promptBuilder = new TestPromptBuilder(); this.qualityChecker = new TestQualityChecker(); } async generateBatch( files: string[], testType: 'unit' | 'integration' | 'e2e' | 'api', conventions?: string ): Promise<BatchResult[]> { const results: BatchResult[] = []; for (const file of files) { const sourceCode = readFileSync(file, 'utf-8'); const context: PromptContext = { sourceCode, sourceFile: file, projectConventions: conventions, }; const prompt = testType === 'unit' ? this.promptBuilder.buildUnitTestPrompt(context) : testType === 'e2e' ? this.promptBuilder.buildE2ETestPrompt(context) : this.promptBuilder.buildIntegrationTestPrompt(context); const startTime = Date.now(); const response = await this.client.messages.create({ model: 'claude-sonnet-4-20250514', max_tokens: 4096, temperature: 0, system: prompt.system, messages: [{ role: 'user', content: prompt.user }], }); const text = response.content[0].type === 'text' ? response.content[0].text : ''; const codeMatch = text.match(/```typescript\n([\s\S]*?)```/); const testCode = codeMatch ? codeMatch[1] : text; const quality = this.qualityChecker.check(testCode); const tokensUsed = (response.usage?.input_tokens || 0) + (response.usage?.output_tokens || 0); results.push({ file, testCode: testCode.trim(), quality, tokensUsed, generationTimeMs: Date.now() - startTime, }); } return results; } }

name	AI Test Generation Patterns
description	Systematic patterns for prompting AI coding agents to generate high-quality tests including prompt engineering for test creation, coverage-driven generation, mutation-aware testing, and review checklists for AI-generated test code.
version	1.0.0
author	thetestingacademy
license	MIT
tags	["ai-testing","test-generation","prompt-engineering","coverage-driven","mutation-testing","code-review","automated-testing","llm-testing","ai-code-generation"]
testingTypes	["unit","integration","e2e","api"]
frameworks	["vitest","jest","playwright","pytest","cypress"]
languages	["typescript","javascript","python"]
domains	["web","backend","api","mobile"]
agents	["claude-code","cursor","github-copilot","windsurf","codex","aider","continue","cline","zed","bolt","gemini-cli","amp"]

name	AI Test Generation Patterns
description	Systematic patterns for prompting AI coding agents to generate high-quality tests including prompt engineering for test creation, coverage-driven generation, mutation-aware testing, and review checklists for AI-generated test code.
version	1.0.0
author	thetestingacademy
license	MIT
tags	["ai-testing","test-generation","prompt-engineering","coverage-driven","mutation-testing","code-review","automated-testing","llm-testing","ai-code-generation"]
testingTypes	["unit","integration","e2e","api"]
frameworks	["vitest","jest","playwright","pytest","cypress"]
languages	["typescript","javascript","python"]
domains	["web","backend","api","mobile"]
agents	["claude-code","cursor","github-copilot","windsurf","codex","aider","continue","cline","zed","bolt","gemini-cli","amp"]

ai-test-generation-patterns

Installationsoptionen

Quelldateien prüfen