dartmind 17.0.0

package/dist/mcp/servers/flutter-test-gen/index.js

@@ -0,0 +1,1030 @@
+/**
+ * FlutterAI V16 - Test Generation MCP Server
+ * Phase 10: Issues 61.1, 61.2, 62.1, 62.2, 63.1, 63.2
+ * Port: 3007
+ *
+ * Tools:
+ * - generate_unit_tests: Generate unit tests for Dart classes
+ * - generate_widget_tests: Generate widget tests for Flutter widgets
+ * - generate_integration_tests: Generate integration tests
+ * - generate_mocks: Generate mock classes (mockito/mocktail)
+ * - analyze_test_coverage: Analyze test coverage and gaps
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+// ============================================================================
+// Tool Definitions
+// ============================================================================
+export const testGenTools = [
+    {
+        name: 'generate_unit_tests',
+        description: 'Generate comprehensive unit tests for Dart classes',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                filePath: { type: 'string', description: 'Path to the Dart file' },
+                className: { type: 'string', description: 'Class to test' },
+                methodNames: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Specific methods to test (optional)'
+                },
+                testStyle: {
+                    type: 'string',
+                    enum: ['arrange-act-assert', 'given-when-then', 'bdd'],
+                    default: 'arrange-act-assert'
+                },
+                mockFramework: {
+                    type: 'string',
+                    enum: ['mockito', 'mocktail'],
+                    default: 'mocktail'
+                },
+                includeEdgeCases: { type: 'boolean', default: true },
+                includeNullSafety: { type: 'boolean', default: true }
+            },
+            required: ['filePath', 'className']
+        }
+    },
+    {
+        name: 'generate_widget_tests',
+        description: 'Generate widget tests with pump, finder, and matcher utilities',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                filePath: { type: 'string', description: 'Path to the widget file' },
+                widgetName: { type: 'string', description: 'Widget class name' },
+                includeGoldenTests: { type: 'boolean', default: false },
+                includeAccessibilityTests: { type: 'boolean', default: true },
+                testStyle: {
+                    type: 'string',
+                    enum: ['arrange-act-assert', 'given-when-then', 'bdd'],
+                    default: 'arrange-act-assert'
+                },
+                mockFramework: {
+                    type: 'string',
+                    enum: ['mockito', 'mocktail'],
+                    default: 'mocktail'
+                }
+            },
+            required: ['filePath', 'widgetName']
+        }
+    },
+    {
+        name: 'generate_integration_tests',
+        description: 'Generate integration tests for user flows',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                flowName: { type: 'string', description: 'Name of the user flow' },
+                steps: {
+                    type: 'array',
+                    items: {
+                        type: 'object',
+                        properties: {
+                            action: { type: 'string', enum: ['tap', 'enter_text', 'scroll', 'wait', 'verify'] },
+                            target: { type: 'string' },
+                            value: { type: 'string' },
+                            description: { type: 'string' }
+                        },
+                        required: ['action', 'target', 'description']
+                    }
+                },
+                includeScreenshots: { type: 'boolean', default: true }
+            },
+            required: ['flowName', 'steps']
+        }
+    },
+    {
+        name: 'generate_mocks',
+        description: 'Generate mock classes for testing with mockito or mocktail',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                filePath: { type: 'string', description: 'Path to the file containing classes to mock' },
+                framework: {
+                    type: 'string',
+                    enum: ['mockito', 'mocktail'],
+                    default: 'mocktail'
+                },
+                classNames: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Specific classes to mock (optional, all if not specified)'
+                },
+                includeStubs: { type: 'boolean', default: true }
+            },
+            required: ['filePath']
+        }
+    },
+    {
+        name: 'analyze_test_coverage',
+        description: 'Analyze test coverage and identify gaps',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                projectPath: { type: 'string', description: 'Path to Flutter project' },
+                threshold: { type: 'number', default: 80, description: 'Coverage threshold percentage' },
+                includeUncovered: { type: 'boolean', default: true }
+            },
+            required: ['projectPath']
+        }
+    }
+];
+// ============================================================================
+// Test Generation Engine
+// ============================================================================
+export class TestGenerationEngine {
+    /**
+     * Generate unit tests for a Dart class
+     */
+    async generateUnitTests(options) {
+        const { filePath, className, methodNames, testStyle = 'arrange-act-assert', mockFramework = 'mocktail', includeEdgeCases = true, includeNullSafety = true } = options;
+        // Read source file
+        let sourceCode;
+        try {
+            sourceCode = fs.readFileSync(filePath, 'utf-8');
+        }
+        catch (error) {
+            return {
+                success: false,
+                code: '',
+                testCount: 0,
+                suggestions: [`Could not read file: ${filePath}`]
+            };
+        }
+        // Parse class information
+        const classInfo = this.parseClass(sourceCode, className);
+        if (!classInfo) {
+            return {
+                success: false,
+                code: '',
+                testCount: 0,
+                suggestions: [`Class '${className}' not found in ${filePath}`]
+            };
+        }
+        // Filter methods if specified
+        const methodsToTest = methodNames
+            ? classInfo.methods.filter(m => methodNames.includes(m.name))
+            : classInfo.methods.filter(m => m.visibility === 'public' && !m.name.startsWith('_'));
+        // Generate test code
+        const tests = [];
+        let testCount = 0;
+        // Generate imports
+        const imports = this.generateUnitTestImports(filePath, mockFramework, classInfo);
+        tests.push(imports);
+        // Generate mock classes
+        if (classInfo.dependencies.length > 0) {
+            const mocks = this.generateMockClasses(classInfo.dependencies, mockFramework);
+            tests.push(mocks);
+        }
+        // Generate test group
+        tests.push(`\nvoid main() {`);
+        tests.push(`  group('${className}', () {`);
+        // Generate setUp
+        tests.push(this.generateSetUp(classInfo, mockFramework));
+        // Generate tests for each method
+        for (const method of methodsToTest) {
+            const methodTests = this.generateMethodTests(classInfo, method, testStyle, mockFramework, includeEdgeCases, includeNullSafety);
+            tests.push(methodTests.code);
+            testCount += methodTests.count;
+        }
+        tests.push(`  });`);
+        tests.push(`}`);
+        return {
+            success: true,
+            code: tests.join('\n'),
+            testCount,
+            suggestions: this.generateTestSuggestions(classInfo, methodsToTest)
+        };
+    }
+    /**
+     * Generate widget tests
+     */
+    async generateWidgetTests(options) {
+        const { filePath, widgetName, includeGoldenTests = false, includeAccessibilityTests = true, testStyle = 'arrange-act-assert', mockFramework = 'mocktail' } = options;
+        // Read source file
+        let sourceCode;
+        try {
+            sourceCode = fs.readFileSync(filePath, 'utf-8');
+        }
+        catch (error) {
+            return {
+                success: false,
+                code: '',
+                testCount: 0,
+                suggestions: [`Could not read file: ${filePath}`]
+            };
+        }
+        // Parse widget information
+        const widgetInfo = this.parseWidget(sourceCode, widgetName);
+        if (!widgetInfo) {
+            return {
+                success: false,
+                code: '',
+                testCount: 0,
+                suggestions: [`Widget '${widgetName}' not found in ${filePath}`]
+            };
+        }
+        const tests = [];
+        let testCount = 0;
+        // Generate imports
+        tests.push(this.generateWidgetTestImports(filePath, mockFramework, includeGoldenTests));
+        // Generate mock classes for dependencies
+        if (widgetInfo.dependencies.length > 0) {
+            tests.push(this.generateMockClasses(widgetInfo.dependencies, mockFramework));
+        }
+        // Generate test helper
+        tests.push(this.generateWidgetTestHelper(widgetInfo, mockFramework));
+        // Main test group
+        tests.push(`\nvoid main() {`);
+        tests.push(`  group('${widgetName}', () {`);
+        // Rendering test
+        tests.push(this.generateRenderingTest(widgetInfo, testStyle));
+        testCount++;
+        // Interaction tests
+        const interactionTests = this.generateInteractionTests(widgetInfo, testStyle);
+        tests.push(interactionTests.code);
+        testCount += interactionTests.count;
+        // State tests (for StatefulWidget)
+        if (widgetInfo.isStateful) {
+            const stateTests = this.generateStateTests(widgetInfo, testStyle);
+            tests.push(stateTests.code);
+            testCount += stateTests.count;
+        }
+        // Accessibility tests
+        if (includeAccessibilityTests) {
+            tests.push(this.generateAccessibilityTests(widgetInfo));
+            testCount += 2; // Semantics + contrast tests
+        }
+        // Golden tests
+        if (includeGoldenTests) {
+            tests.push(this.generateGoldenTests(widgetInfo));
+            testCount++;
+        }
+        tests.push(`  });`);
+        tests.push(`}`);
+        return {
+            success: true,
+            code: tests.join('\n'),
+            testCount,
+            suggestions: this.generateWidgetTestSuggestions(widgetInfo)
+        };
+    }
+    /**
+     * Generate integration tests
+     */
+    async generateIntegrationTests(options) {
+        const { flowName, steps, includeScreenshots = true } = options;
+        const tests = [];
+        let testCount = 1;
+        // Generate imports
+        tests.push(`import 'package:flutter_test/flutter_test.dart';`);
+        tests.push(`import 'package:integration_test/integration_test.dart';`);
+        tests.push(`import 'package:your_app/main.dart' as app;`);
+        tests.push('');
+        tests.push(`void main() {`);
+        tests.push(`  IntegrationTestWidgetsFlutterBinding.ensureInitialized();`);
+        tests.push('');
+        tests.push(`  group('${flowName}', () {`);
+        // Generate main flow test
+        tests.push(`    testWidgets('${flowName} completes successfully', (tester) async {`);
+        tests.push(`      app.main();`);
+        tests.push(`      await tester.pumpAndSettle();`);
+        tests.push('');
+        let stepIndex = 0;
+        for (const step of steps) {
+            tests.push(`      // Step ${stepIndex + 1}: ${step.description}`);
+            tests.push(this.generateIntegrationStep(step, stepIndex, includeScreenshots));
+            tests.push('');
+            stepIndex++;
+        }
+        tests.push(`    });`);
+        // Generate error handling test
+        tests.push('');
+        tests.push(`    testWidgets('${flowName} handles errors gracefully', (tester) async {`);
+        tests.push(`      app.main();`);
+        tests.push(`      await tester.pumpAndSettle();`);
+        tests.push('');
+        tests.push(`      // TODO: Add error scenario tests`);
+        tests.push(`      // Example: Test network failure, invalid input, etc.`);
+        tests.push(`    });`);
+        testCount++;
+        tests.push(`  });`);
+        tests.push(`}`);
+        return {
+            success: true,
+            code: tests.join('\n'),
+            testCount,
+            suggestions: [
+                'Consider adding tests for error scenarios',
+                'Add screenshot comparisons for visual regression testing',
+                'Test with different screen sizes and orientations'
+            ]
+        };
+    }
+    /**
+     * Generate mock classes
+     */
+    async generateMocks(options) {
+        const { filePath, framework = 'mocktail', classNames, includeStubs = true } = options;
+        // Read source file
+        let sourceCode;
+        try {
+            sourceCode = fs.readFileSync(filePath, 'utf-8');
+        }
+        catch (error) {
+            return {
+                success: false,
+                code: '',
+                testCount: 0,
+                suggestions: [`Could not read file: ${filePath}`]
+            };
+        }
+        // Parse all classes
+        const allClasses = this.parseAllClasses(sourceCode);
+        // Filter classes if specified
+        const classesToMock = classNames
+            ? allClasses.filter(c => classNames.includes(c.name))
+            : allClasses.filter(c => c.isAbstract || c.methods.length > 0);
+        if (classesToMock.length === 0) {
+            return {
+                success: false,
+                code: '',
+                testCount: 0,
+                suggestions: ['No mockable classes found in the file']
+            };
+        }
+        const mocks = [];
+        // Generate imports
+        if (framework === 'mockito') {
+            mocks.push(`import 'package:mockito/mockito.dart';`);
+            mocks.push(`import 'package:mockito/annotations.dart';`);
+        }
+        else {
+            mocks.push(`import 'package:mocktail/mocktail.dart';`);
+        }
+        const relativePath = path.basename(filePath).replace('.dart', '');
+        mocks.push(`import '${relativePath}.dart';`);
+        mocks.push('');
+        // Generate mock classes
+        for (const classInfo of classesToMock) {
+            if (framework === 'mockito') {
+                mocks.push(this.generateMockitoMock(classInfo, includeStubs));
+            }
+            else {
+                mocks.push(this.generateMocktailMock(classInfo, includeStubs));
+            }
+            mocks.push('');
+        }
+        // Generate setup helper
+        mocks.push(this.generateMockSetupHelper(classesToMock, framework));
+        return {
+            success: true,
+            code: mocks.join('\n'),
+            testCount: classesToMock.length,
+            suggestions: [
+                'Import this file in your test files',
+                'Call registerFallbackValues() in setUpAll() for mocktail',
+                'Run build_runner for mockito to generate mocks'
+            ]
+        };
+    }
+    /**
+     * Analyze test coverage
+     */
+    async analyzeTestCoverage(options) {
+        const { projectPath, threshold = 80, includeUncovered = true } = options;
+        // In a real implementation, this would run `flutter test --coverage`
+        // and parse the lcov.info file. For now, we generate a structure.
+        const coverage = {
+            linesCovered: 0,
+            linesTotal: 0,
+            percentage: 0,
+            uncoveredFiles: [],
+            uncoveredMethods: []
+        };
+        // Check for coverage file
+        const coveragePath = path.join(projectPath, 'coverage', 'lcov.info');
+        if (fs.existsSync(coveragePath)) {
+            const lcovContent = fs.readFileSync(coveragePath, 'utf-8');
+            const parsed = this.parseLcovInfo(lcovContent);
+            coverage.linesCovered = parsed.linesCovered;
+            coverage.linesTotal = parsed.linesTotal;
+            coverage.percentage = parsed.percentage;
+            coverage.uncoveredFiles = parsed.uncoveredFiles;
+            coverage.uncoveredMethods = parsed.uncoveredMethods;
+        }
+        // Generate analysis report
+        const report = [];
+        report.push('# Test Coverage Analysis Report');
+        report.push('');
+        report.push(`## Summary`);
+        report.push(`- **Lines Covered**: ${coverage.linesCovered}/${coverage.linesTotal}`);
+        report.push(`- **Coverage**: ${coverage.percentage.toFixed(1)}%`);
+        report.push(`- **Threshold**: ${threshold}%`);
+        report.push(`- **Status**: ${coverage.percentage >= threshold ? '✅ PASSING' : '❌ FAILING'}`);
+        report.push('');
+        if (includeUncovered && coverage.uncoveredFiles.length > 0) {
+            report.push(`## Uncovered Files`);
+            for (const file of coverage.uncoveredFiles) {
+                report.push(`- ${file}`);
+            }
+            report.push('');
+        }
+        if (includeUncovered && coverage.uncoveredMethods.length > 0) {
+            report.push(`## Uncovered Methods`);
+            for (const method of coverage.uncoveredMethods.slice(0, 20)) {
+                report.push(`- ${method}`);
+            }
+            if (coverage.uncoveredMethods.length > 20) {
+                report.push(`- ... and ${coverage.uncoveredMethods.length - 20} more`);
+            }
+            report.push('');
+        }
+        // Generate suggestions
+        const suggestions = [];
+        if (coverage.percentage < threshold) {
+            suggestions.push(`Increase coverage by ${(threshold - coverage.percentage).toFixed(1)}% to meet threshold`);
+        }
+        if (coverage.uncoveredFiles.length > 0) {
+            suggestions.push(`Add tests for ${coverage.uncoveredFiles.length} uncovered files`);
+        }
+        suggestions.push('Focus on critical paths and error handling');
+        suggestions.push('Consider using code coverage tools in CI/CD');
+        return {
+            success: true,
+            code: report.join('\n'),
+            testCount: 0,
+            coverage,
+            suggestions
+        };
+    }
+    // ============================================================================
+    // Private Helper Methods
+    // ============================================================================
+    parseClass(code, className) {
+        // Parse class definition
+        const classRegex = new RegExp(`(abstract\\s+)?class\\s+${className}(?:<[^>]+>)?(?:\\s+extends\\s+\\w+)?(?:\\s+(?:with|implements)\\s+[\\w,\\s]+)?\\s*\\{`, 'g');
+        const match = classRegex.exec(code);
+        if (!match)
+            return null;
+        const isAbstract = !!match[1];
+        const startIndex = match.index + match[0].length;
+        // Find class body
+        let braceCount = 1;
+        let endIndex = startIndex;
+        while (braceCount > 0 && endIndex < code.length) {
+            if (code[endIndex] === '{')
+                braceCount++;
+            else if (code[endIndex] === '}')
+                braceCount--;
+            endIndex++;
+        }
+        const classBody = code.substring(startIndex, endIndex - 1);
+        // Parse methods
+        const methods = this.parseMethods(classBody);
+        // Parse dependencies (constructor parameters)
+        const dependencies = this.parseDependencies(classBody, className);
+        return {
+            name: className,
+            methods,
+            dependencies,
+            isAbstract
+        };
+    }
+    parseMethods(classBody) {
+        const methods = [];
+        // Match method signatures
+        const methodRegex = /(?:(static)\s+)?(?:(Future|Stream|void|[\w<>,\s?]+)\s+)?(\w+)\s*\(([^)]*)\)\s*(?:async\s*)?\{/g;
+        let match;
+        while ((match = methodRegex.exec(classBody)) !== null) {
+            const [, isStatic, returnType, name, params] = match;
+            // Skip constructors and private methods
+            if (name === 'build' || name === 'initState' || name === 'dispose')
+                continue;
+            const parameters = this.parseParameters(params);
+            const isAsync = returnType?.includes('Future') || classBody.substring(match.index).includes('async');
+            methods.push({
+                name,
+                returnType: returnType?.trim() || 'void',
+                parameters,
+                isAsync,
+                isStatic: !!isStatic,
+                visibility: name.startsWith('_') ? 'private' : 'public'
+            });
+        }
+        return methods;
+    }
+    parseParameters(params) {
+        if (!params.trim())
+            return [];
+        const parameters = [];
+        const parts = params.split(',').map(p => p.trim()).filter(p => p);
+        for (const part of parts) {
+            const isNamed = part.startsWith('{') || part.includes('required');
+            const isRequired = part.includes('required') || !part.includes('?');
+            // Extract type and name
+            const cleaned = part.replace(/[{}]/g, '').replace('required', '').trim();
+            const match = cleaned.match(/(\w+(?:<[^>]+>)?)\??\s+(\w+)(?:\s*=\s*(.+))?/);
+            if (match) {
+                parameters.push({
+                    name: match[2],
+                    type: match[1],
+                    isRequired,
+                    isNamed,
+                    defaultValue: match[3]
+                });
+            }
+        }
+        return parameters;
+    }
+    parseDependencies(classBody, className) {
+        const dependencies = [];
+        // Look for constructor parameters
+        const constructorRegex = new RegExp(`${className}\\s*\\(([^)]+)\\)`, 'g');
+        const match = constructorRegex.exec(classBody);
+        if (match) {
+            const params = match[1];
+            // Extract type names from parameters
+            const typeRegex = /(\w+(?:<[^>]+>)?)\s+\w+/g;
+            let typeMatch;
+            while ((typeMatch = typeRegex.exec(params)) !== null) {
+                const typeName = typeMatch[1];
+                if (!['String', 'int', 'double', 'bool', 'List', 'Map', 'Set', 'Key'].includes(typeName)) {
+                    dependencies.push(typeName);
+                }
+            }
+        }
+        return [...new Set(dependencies)];
+    }
+    parseWidget(code, widgetName) {
+        const classInfo = this.parseClass(code, widgetName);
+        if (!classInfo)
+            return null;
+        const isStateful = code.includes(`extends StatefulWidget`) &&
+            code.includes(`class ${widgetName}`) &&
+            code.includes(`createState()`);
+        return { ...classInfo, isStateful };
+    }
+    parseAllClasses(code) {
+        const classes = [];
+        const classRegex = /(?:abstract\s+)?class\s+(\w+)/g;
+        let match;
+        while ((match = classRegex.exec(code)) !== null) {
+            const classInfo = this.parseClass(code, match[1]);
+            if (classInfo) {
+                classes.push(classInfo);
+            }
+        }
+        return classes;
+    }
+    generateUnitTestImports(filePath, mockFramework, classInfo) {
+        const imports = [];
+        imports.push(`import 'package:flutter_test/flutter_test.dart';`);
+        if (mockFramework === 'mockito') {
+            imports.push(`import 'package:mockito/mockito.dart';`);
+            imports.push(`import 'package:mockito/annotations.dart';`);
+        }
+        else {
+            imports.push(`import 'package:mocktail/mocktail.dart';`);
+        }
+        // Convert file path to import
+        const relativePath = path.basename(filePath);
+        imports.push(`import '${relativePath.replace('.dart', '')}.dart';`);
+        return imports.join('\n') + '\n';
+    }
+    generateWidgetTestImports(filePath, mockFramework, includeGolden) {
+        const imports = [];
+        imports.push(`import 'package:flutter/material.dart';`);
+        imports.push(`import 'package:flutter_test/flutter_test.dart';`);
+        if (mockFramework === 'mocktail') {
+            imports.push(`import 'package:mocktail/mocktail.dart';`);
+        }
+        else {
+            imports.push(`import 'package:mockito/mockito.dart';`);
+        }
+        if (includeGolden) {
+            imports.push(`import 'package:golden_toolkit/golden_toolkit.dart';`);
+        }
+        const relativePath = path.basename(filePath);
+        imports.push(`import '${relativePath.replace('.dart', '')}.dart';`);
+        return imports.join('\n') + '\n';
+    }
+    generateMockClasses(dependencies, framework) {
+        const mocks = [];
+        for (const dep of dependencies) {
+            if (framework === 'mocktail') {
+                mocks.push(`class Mock${dep} extends Mock implements ${dep} {}`);
+            }
+            else {
+                mocks.push(`@GenerateMocks([${dep}])`);
+            }
+        }
+        return mocks.join('\n') + '\n';
+    }
+    generateSetUp(classInfo, mockFramework) {
+        const lines = [];
+        lines.push(`    late ${classInfo.name} sut;`);
+        for (const dep of classInfo.dependencies) {
+            lines.push(`    late Mock${dep} mock${dep};`);
+        }
+        lines.push('');
+        lines.push(`    setUp(() {`);
+        for (const dep of classInfo.dependencies) {
+            lines.push(`      mock${dep} = Mock${dep}();`);
+        }
+        const constructorParams = classInfo.dependencies.map(d => `mock${d}`).join(', ');
+        lines.push(`      sut = ${classInfo.name}(${constructorParams});`);
+        lines.push(`    });`);
+        lines.push('');
+        return lines.join('\n');
+    }
+    generateMethodTests(classInfo, method, testStyle, mockFramework, includeEdgeCases, includeNullSafety) {
+        const tests = [];
+        let count = 0;
+        tests.push(`    group('${method.name}', () {`);
+        // Happy path test
+        tests.push(this.generateHappyPathTest(classInfo, method, testStyle, mockFramework));
+        count++;
+        // Edge case tests
+        if (includeEdgeCases) {
+            const edgeTests = this.generateEdgeCaseTests(classInfo, method, testStyle);
+            tests.push(edgeTests.code);
+            count += edgeTests.count;
+        }
+        // Null safety tests
+        if (includeNullSafety && method.parameters.some(p => p.type.includes('?'))) {
+            tests.push(this.generateNullSafetyTest(classInfo, method, testStyle));
+            count++;
+        }
+        tests.push(`    });`);
+        tests.push('');
+        return { code: tests.join('\n'), count };
+    }
+    generateHappyPathTest(classInfo, method, testStyle, mockFramework) {
+        const testName = testStyle === 'bdd'
+            ? `'should ${method.name.replace(/([A-Z])/g, ' $1').toLowerCase()} successfully'`
+            : `'returns expected result when called with valid parameters'`;
+        const lines = [];
+        lines.push(`      test(${testName}, () ${method.isAsync ? 'async ' : ''}{`);
+        if (testStyle === 'arrange-act-assert') {
+            lines.push(`        // Arrange`);
+            lines.push(this.generateArrangeSection(classInfo, method, mockFramework));
+            lines.push('');
+            lines.push(`        // Act`);
+            lines.push(this.generateActSection(method));
+            lines.push('');
+            lines.push(`        // Assert`);
+            lines.push(this.generateAssertSection(method, mockFramework));
+        }
+        else {
+            lines.push(`        // Given`);
+            lines.push(this.generateArrangeSection(classInfo, method, mockFramework));
+            lines.push('');
+            lines.push(`        // When`);
+            lines.push(this.generateActSection(method));
+            lines.push('');
+            lines.push(`        // Then`);
+            lines.push(this.generateAssertSection(method, mockFramework));
+        }
+        lines.push(`      });`);
+        lines.push('');
+        return lines.join('\n');
+    }
+    generateArrangeSection(classInfo, method, mockFramework) {
+        const lines = [];
+        // Set up mock responses
+        for (const dep of classInfo.dependencies) {
+            if (mockFramework === 'mocktail') {
+                lines.push(`        when(() => mock${dep}.someMethod()).thenReturn(expectedValue);`);
+            }
+            else {
+                lines.push(`        when(mock${dep}.someMethod()).thenReturn(expectedValue);`);
+            }
+        }
+        // Set up test parameters
+        for (const param of method.parameters) {
+            lines.push(`        final ${param.name} = ${this.getTestValue(param.type)};`);
+        }
+        return lines.join('\n');
+    }
+    generateActSection(method) {
+        const params = method.parameters.map(p => p.isNamed ? `${p.name}: ${p.name}` : p.name).join(', ');
+        const awaitPrefix = method.isAsync ? 'await ' : '';
+        return `        final result = ${awaitPrefix}sut.${method.name}(${params});`;
+    }
+    generateAssertSection(method, mockFramework) {
+        const lines = [];
+        if (method.returnType !== 'void') {
+            lines.push(`        expect(result, isNotNull);`);
+            lines.push(`        expect(result, equals(expectedResult));`);
+        }
+        return lines.join('\n');
+    }
+    generateEdgeCaseTests(classInfo, method, testStyle) {
+        const tests = [];
+        let count = 0;
+        // Empty input test
+        if (method.parameters.some(p => p.type === 'String' || p.type.includes('List'))) {
+            tests.push(`      test('handles empty input', () ${method.isAsync ? 'async ' : ''}{`);
+            tests.push(`        // Test with empty values`);
+            tests.push(`        expect(() => sut.${method.name}(), returnsNormally);`);
+            tests.push(`      });`);
+            tests.push('');
+            count++;
+        }
+        // Exception handling test
+        tests.push(`      test('throws exception on invalid input', () {`);
+        tests.push(`        expect(`);
+        tests.push(`          () => sut.${method.name}(/* invalid params */),`);
+        tests.push(`          throwsA(isA<Exception>()),`);
+        tests.push(`        );`);
+        tests.push(`      });`);
+        tests.push('');
+        count++;
+        return { code: tests.join('\n'), count };
+    }
+    generateNullSafetyTest(classInfo, method, testStyle) {
+        return `      test('handles null parameters gracefully', () {
+        // Test nullable parameter handling
+        expect(() => sut.${method.name}(null), returnsNormally);
+      });
+`;
+    }
+    generateWidgetTestHelper(widgetInfo, mockFramework) {
+        const lines = [];
+        lines.push(`Widget buildTestWidget({`);
+        for (const dep of widgetInfo.dependencies) {
+            lines.push(`  ${dep}? ${dep.toLowerCase()},`);
+        }
+        lines.push(`}) {`);
+        lines.push(`  return MaterialApp(`);
+        lines.push(`    home: Scaffold(`);
+        lines.push(`      body: ${widgetInfo.name}(`);
+        for (const dep of widgetInfo.dependencies) {
+            lines.push(`        ${dep.toLowerCase()}: ${dep.toLowerCase()} ?? Mock${dep}(),`);
+        }
+        lines.push(`      ),`);
+        lines.push(`    ),`);
+        lines.push(`  );`);
+        lines.push(`}`);
+        lines.push('');
+        return lines.join('\n');
+    }
+    generateRenderingTest(widgetInfo, testStyle) {
+        return `    testWidgets('renders correctly', (tester) async {
+      // ${testStyle === 'bdd' ? 'Given' : 'Arrange'}
+      await tester.pumpWidget(buildTestWidget());
+
+      // ${testStyle === 'bdd' ? 'Then' : 'Assert'}
+      expect(find.byType(${widgetInfo.name}), findsOneWidget);
+    });
+`;
+    }
+    generateInteractionTests(widgetInfo, testStyle) {
+        const tests = [];
+        let count = 0;
+        tests.push(`    testWidgets('responds to tap interactions', (tester) async {`);
+        tests.push(`      await tester.pumpWidget(buildTestWidget());`);
+        tests.push(``);
+        tests.push(`      // Find and tap interactive elements`);
+        tests.push(`      final button = find.byType(ElevatedButton);`);
+        tests.push(`      if (button.evaluate().isNotEmpty) {`);
+        tests.push(`        await tester.tap(button.first);`);
+        tests.push(`        await tester.pumpAndSettle();`);
+        tests.push(`      }`);
+        tests.push(`    });`);
+        tests.push('');
+        count++;
+        return { code: tests.join('\n'), count };
+    }
+    generateStateTests(widgetInfo, testStyle) {
+        const tests = [];
+        let count = 0;
+        tests.push(`    testWidgets('updates state correctly', (tester) async {`);
+        tests.push(`      await tester.pumpWidget(buildTestWidget());`);
+        tests.push(``);
+        tests.push(`      // Trigger state change`);
+        tests.push(`      // await tester.tap(find.byKey(Key('trigger')));`);
+        tests.push(`      // await tester.pumpAndSettle();`);
+        tests.push(``);
+        tests.push(`      // Verify state updated`);
+        tests.push(`      // expect(find.text('Updated'), findsOneWidget);`);
+        tests.push(`    });`);
+        tests.push('');
+        count++;
+        return { code: tests.join('\n'), count };
+    }
+    generateAccessibilityTests(widgetInfo) {
+        return `    testWidgets('meets accessibility guidelines', (tester) async {
+      await tester.pumpWidget(buildTestWidget());
+
+      // Check semantics
+      final semantics = tester.getSemantics(find.byType(${widgetInfo.name}));
+      expect(semantics.hasFlag(SemanticsFlag.isEnabled), isTrue);
+    });
+
+    testWidgets('supports screen readers', (tester) async {
+      await tester.pumpWidget(buildTestWidget());
+
+      // Verify semantic labels exist
+      expect(
+        find.bySemanticsLabel(RegExp('.*')),
+        findsWidgets,
+      );
+    });
+`;
+    }
+    generateGoldenTests(widgetInfo) {
+        return `    testGoldens('matches golden image', (tester) async {
+      await tester.pumpWidgetBuilder(
+        buildTestWidget(),
+        surfaceSize: const Size(400, 600),
+      );
+
+      await screenMatchesGolden(tester, '${widgetInfo.name.toLowerCase()}_default');
+    });
+`;
+    }
+    generateIntegrationStep(step, index, includeScreenshots) {
+        const lines = [];
+        switch (step.action) {
+            case 'tap':
+                lines.push(`      await tester.tap(find.${step.target.includes('Key') ? `byKey(${step.target})` : `text('${step.target}')`});`);
+                lines.push(`      await tester.pumpAndSettle();`);
+                break;
+            case 'enter_text':
+                lines.push(`      await tester.enterText(find.${step.target.includes('Key') ? `byKey(${step.target})` : `byType(TextField)`}, '${step.value}');`);
+                lines.push(`      await tester.pumpAndSettle();`);
+                break;
+            case 'scroll':
+                lines.push(`      await tester.drag(find.byType(ListView), const Offset(0, -300));`);
+                lines.push(`      await tester.pumpAndSettle();`);
+                break;
+            case 'wait':
+                lines.push(`      await tester.pump(const Duration(seconds: ${step.value || '1'}));`);
+                break;
+            case 'verify':
+                lines.push(`      expect(find.text('${step.target}'), findsOneWidget);`);
+                break;
+        }
+        if (includeScreenshots) {
+            lines.push(`      await binding.takeScreenshot('step_${index + 1}_${step.action}');`);
+        }
+        return lines.join('\n');
+    }
+    generateMockitoMock(classInfo, includeStubs) {
+        const lines = [];
+        lines.push(`// Mock for ${classInfo.name}`);
+        lines.push(`class Mock${classInfo.name} extends Mock implements ${classInfo.name} {}`);
+        if (includeStubs) {
+            lines.push('');
+            lines.push(`// Stub helpers for ${classInfo.name}`);
+            lines.push(`extension Mock${classInfo.name}Stubs on Mock${classInfo.name} {`);
+            for (const method of classInfo.methods.filter(m => m.visibility === 'public')) {
+                const params = method.parameters.map(p => `${p.type} ${p.name}`).join(', ');
+                const returnValue = this.getDefaultReturnValue(method.returnType);
+                lines.push(`  void stubbed${this.capitalize(method.name)}(${params}) {`);
+                lines.push(`    when(${method.name}(${method.parameters.map(p => 'any').join(', ')})).thenReturn(${returnValue});`);
+                lines.push(`  }`);
+            }
+            lines.push(`}`);
+        }
+        return lines.join('\n');
+    }
+    generateMocktailMock(classInfo, includeStubs) {
+        const lines = [];
+        lines.push(`// Mock for ${classInfo.name}`);
+        lines.push(`class Mock${classInfo.name} extends Mock implements ${classInfo.name} {}`);
+        if (includeStubs) {
+            lines.push('');
+            lines.push(`// Stub helpers for ${classInfo.name}`);
+            lines.push(`extension Mock${classInfo.name}Stubs on Mock${classInfo.name} {`);
+            for (const method of classInfo.methods.filter(m => m.visibility === 'public')) {
+                const returnValue = this.getDefaultReturnValue(method.returnType);
+                lines.push(`  void stubbed${this.capitalize(method.name)}() {`);
+                lines.push(`    when(() => ${method.name}(${method.parameters.map(p => 'any()').join(', ')})).thenReturn(${returnValue});`);
+                lines.push(`  }`);
+            }
+            lines.push(`}`);
+        }
+        return lines.join('\n');
+    }
+    generateMockSetupHelper(classes, framework) {
+        const lines = [];
+        lines.push('// Setup helper for all mocks');
+        lines.push('void setUpMocks() {');
+        if (framework === 'mocktail') {
+            lines.push('  setUpAll(() {');
+            lines.push('    // Register fallback values for custom types');
+            for (const classInfo of classes) {
+                lines.push(`    registerFallbackValue(Mock${classInfo.name}());`);
+            }
+            lines.push('  });');
+        }
+        lines.push('}');
+        return lines.join('\n');
+    }
+    parseLcovInfo(content) {
+        let linesCovered = 0;
+        let linesTotal = 0;
+        const uncoveredFiles = [];
+        const uncoveredMethods = [];
+        const lines = content.split('\n');
+        let currentFile = '';
+        let fileCovered = 0;
+        let fileTotal = 0;
+        for (const line of lines) {
+            if (line.startsWith('SF:')) {
+                currentFile = line.substring(3);
+                fileCovered = 0;
+                fileTotal = 0;
+            }
+            else if (line.startsWith('DA:')) {
+                const [, count] = line.substring(3).split(',');
+                fileTotal++;
+                if (parseInt(count) > 0) {
+                    fileCovered++;
+                }
+            }
+            else if (line.startsWith('FN:')) {
+                // Function name
+                const fnName = line.split(',')[1];
+                if (fnName) {
+                    uncoveredMethods.push(`${currentFile}:${fnName}`);
+                }
+            }
+            else if (line === 'end_of_record') {
+                linesCovered += fileCovered;
+                linesTotal += fileTotal;
+                if (fileTotal > 0 && fileCovered / fileTotal < 0.5) {
+                    uncoveredFiles.push(currentFile);
+                }
+            }
+        }
+        return {
+            linesCovered,
+            linesTotal,
+            percentage: linesTotal > 0 ? (linesCovered / linesTotal) * 100 : 0,
+            uncoveredFiles,
+            uncoveredMethods
+        };
+    }
+    generateTestSuggestions(classInfo, methods) {
+        const suggestions = [];
+        if (classInfo.dependencies.length > 0) {
+            suggestions.push(`Mock ${classInfo.dependencies.length} dependencies for isolation`);
+        }
+        const asyncMethods = methods.filter(m => m.isAsync);
+        if (asyncMethods.length > 0) {
+            suggestions.push(`Test async error handling for ${asyncMethods.length} async methods`);
+        }
+        suggestions.push('Consider adding performance tests for critical methods');
+        suggestions.push('Add tests for concurrent access if applicable');
+        return suggestions;
+    }
+    generateWidgetTestSuggestions(widgetInfo) {
+        const suggestions = [];
+        if (widgetInfo.isStateful) {
+            suggestions.push('Test state persistence across rebuilds');
+            suggestions.push('Verify dispose is called to prevent memory leaks');
+        }
+        suggestions.push('Test widget behavior with different themes');
+        suggestions.push('Add tests for different screen sizes');
+        suggestions.push('Consider testing keyboard navigation');
+        return suggestions;
+    }
+    getTestValue(type) {
+        const typeMap = {
+            'String': "'test'",
+            'int': '42',
+            'double': '3.14',
+            'bool': 'true',
+            'List': '[]',
+            'Map': '{}',
+            'Set': '{}',
+        };
+        for (const [key, value] of Object.entries(typeMap)) {
+            if (type.includes(key))
+                return value;
+        }
+        return 'MockObject()';
+    }
+    getDefaultReturnValue(type) {
+        if (type === 'void')
+            return '';
+        if (type.startsWith('Future'))
+            return 'Future.value()';
+        if (type.startsWith('Stream'))
+            return 'Stream.empty()';
+        return this.getTestValue(type);
+    }
+    capitalize(str) {
+        return str.charAt(0).toUpperCase() + str.slice(1);
+    }
+}
+// ============================================================================
+// Export
+// ============================================================================
+export const testGenerationEngine = new TestGenerationEngine();
+//# sourceMappingURL=index.js.map