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.

Ir para a instalação

Repositório: PramodDutta/qaskills
Última atividade na origem: 14 de abril de 2026 às 07:59
Idioma detectado do SKILL.md: inglês
Estrelas: 201
Forks: 21

Opções de instalação

Por padrão, está selecionado o prompt que primeiro revisa a origem. Você pode mudar para um comando direto ou baixar uma cópia local.

Instalar com Codex ou Claude Copie este prompt, cole no Codex, Claude ou outro assistente e deixe que ele revise a página da skill e instale para você.

Um comando direto ignora o prompt de revisão. Verifique a origem antes de executá-lo.

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

O comando permanece em uma só linha. Role horizontalmente para revisá-lo antes de copiar.

Prefere uma cópia local? Baixe os arquivos disponíveis atualmente no SkillsMP.

Revise os arquivos de origem

Leia o SKILL.md e os arquivos complementares exibidos pelo SkillsMP antes de decidir se vai instalar.

SKILL.md

Instruções da origem · Visualização somente leitura

Voltar à pesquisa Voltar à instalação

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

Ver todas deste repositório

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

Opções de instalação

Revise os arquivos de origem