@nahisaho/musubix-core 1.0.0

package/dist/codegen/unit-test-generator.js

@@ -0,0 +1,634 @@
+/**
+ * Unit Test Generator
+ *
+ * Generates unit tests from code and specifications
+ *
+ * @packageDocumentation
+ * @module codegen/unit-test-generator
+ *
+ * @see REQ-TST-001 - Unit Test Generation
+ * @see Article VII - Quality Assurance Standards
+ */
+/**
+ * Default configuration
+ */
+export const DEFAULT_TEST_GENERATOR_CONFIG = {
+    framework: 'jest',
+    assertionStyle: 'expect',
+    generateEdgeCases: true,
+    generateErrorCases: true,
+    generateNullCases: true,
+    maxTestCasesPerFunction: 10,
+    includeSetupTeardown: true,
+    generateMocks: true,
+    testFileSuffix: '.test',
+    testDirectory: '__tests__',
+    verboseDescriptions: true,
+};
+/**
+ * Framework templates
+ */
+const FRAMEWORK_TEMPLATES = {
+    jest: {
+        imports: '',
+        describe: (name, body) => `describe('${name}', () => {\n${body}\n});`,
+        it: (name, body, isAsync) => `  it('${name}', ${isAsync ? 'async ' : ''}() => {\n${body}\n  });`,
+        beforeAll: (body) => `  beforeAll(() => {\n${body}\n  });`,
+        afterAll: (body) => `  afterAll(() => {\n${body}\n  });`,
+        beforeEach: (body) => `  beforeEach(() => {\n${body}\n  });`,
+        afterEach: (body) => `  afterEach(() => {\n${body}\n  });`,
+        expect: (value) => `expect(${value})`,
+        mockFn: () => 'jest.fn()',
+        mockModule: (module) => `jest.mock('${module}')`,
+    },
+    vitest: {
+        imports: "import { describe, it, expect, beforeAll, afterAll, beforeEach, afterEach, vi } from 'vitest';",
+        describe: (name, body) => `describe('${name}', () => {\n${body}\n});`,
+        it: (name, body, isAsync) => `  it('${name}', ${isAsync ? 'async ' : ''}() => {\n${body}\n  });`,
+        beforeAll: (body) => `  beforeAll(() => {\n${body}\n  });`,
+        afterAll: (body) => `  afterAll(() => {\n${body}\n  });`,
+        beforeEach: (body) => `  beforeEach(() => {\n${body}\n  });`,
+        afterEach: (body) => `  afterEach(() => {\n${body}\n  });`,
+        expect: (value) => `expect(${value})`,
+        mockFn: () => 'vi.fn()',
+        mockModule: (module) => `vi.mock('${module}')`,
+    },
+    mocha: {
+        imports: "import { expect } from 'chai';",
+        describe: (name, body) => `describe('${name}', () => {\n${body}\n});`,
+        it: (name, body, isAsync) => `  it('${name}', ${isAsync ? 'async ' : ''}() => {\n${body}\n  });`,
+        beforeAll: (body) => `  before(() => {\n${body}\n  });`,
+        afterAll: (body) => `  after(() => {\n${body}\n  });`,
+        beforeEach: (body) => `  beforeEach(() => {\n${body}\n  });`,
+        afterEach: (body) => `  afterEach(() => {\n${body}\n  });`,
+        expect: (value) => `expect(${value})`,
+        mockFn: () => "sinon.stub()",
+        mockModule: (module) => `// Mock ${module} with sinon or proxyquire`,
+    },
+    ava: {
+        imports: "import test from 'ava';",
+        describe: (name, body) => `// ${name}\n${body}`,
+        it: (name, body, isAsync) => `test('${name}', ${isAsync ? 'async ' : ''}(t) => {\n${body.replace(/expect\(/g, 't.is(')}\n});`,
+        beforeAll: (body) => `test.before(() => {\n${body}\n});`,
+        afterAll: (body) => `test.after(() => {\n${body}\n});`,
+        beforeEach: (body) => `test.beforeEach(() => {\n${body}\n});`,
+        afterEach: (body) => `test.afterEach(() => {\n${body}\n});`,
+        expect: (value) => `t.is(${value}`,
+        mockFn: () => "sinon.stub()",
+        mockModule: (module) => `// Mock ${module} with proxyquire`,
+    },
+    tap: {
+        imports: "import tap from 'tap';",
+        describe: (name, body) => `tap.test('${name}', (t) => {\n${body}\n  t.end();\n});`,
+        it: (name, body, isAsync) => `  t.test('${name}', ${isAsync ? 'async ' : ''}(t) => {\n${body}\n    t.end();\n  });`,
+        beforeAll: (body) => `  t.before(() => {\n${body}\n  });`,
+        afterAll: (body) => `  t.after(() => {\n${body}\n  });`,
+        beforeEach: (body) => `  t.beforeEach(() => {\n${body}\n  });`,
+        afterEach: (body) => `  t.afterEach(() => {\n${body}\n  });`,
+        expect: (value) => `t.equal(${value}`,
+        mockFn: () => "sinon.stub()",
+        mockModule: (module) => `// Mock ${module}`,
+    },
+    pytest: {
+        imports: 'import pytest\nfrom unittest.mock import Mock, patch',
+        describe: (name, body) => `class Test${name.replace(/\s+/g, '')}:\n${body}`,
+        it: (name, body, isAsync) => `    ${isAsync ? 'async ' : ''}def test_${name.replace(/\s+/g, '_').toLowerCase()}(self):\n${body}`,
+        beforeAll: (body) => `    @classmethod\n    def setup_class(cls):\n${body}`,
+        afterAll: (body) => `    @classmethod\n    def teardown_class(cls):\n${body}`,
+        beforeEach: (body) => `    def setup_method(self):\n${body}`,
+        afterEach: (body) => `    def teardown_method(self):\n${body}`,
+        expect: (value) => `assert ${value}`,
+        mockFn: () => 'Mock()',
+        mockModule: (module) => `@patch('${module}')`,
+    },
+    unittest: {
+        imports: 'import unittest\nfrom unittest.mock import Mock, patch',
+        describe: (name, body) => `class Test${name.replace(/\s+/g, '')}(unittest.TestCase):\n${body}`,
+        it: (name, body, _isAsync) => `    def test_${name.replace(/\s+/g, '_').toLowerCase()}(self):\n${body}`,
+        beforeAll: (body) => `    @classmethod\n    def setUpClass(cls):\n${body}`,
+        afterAll: (body) => `    @classmethod\n    def tearDownClass(cls):\n${body}`,
+        beforeEach: (body) => `    def setUp(self):\n${body}`,
+        afterEach: (body) => `    def tearDown(self):\n${body}`,
+        expect: (value) => `self.assertEqual(${value}`,
+        mockFn: () => 'Mock()',
+        mockModule: (module) => `@patch('${module}')`,
+    },
+    junit: {
+        imports: 'import org.junit.jupiter.api.*;\nimport static org.junit.jupiter.api.Assertions.*;',
+        describe: (name, body) => `class ${name.replace(/\s+/g, '')}Test {\n${body}\n}`,
+        it: (name, body, _isAsync) => `    @Test\n    void test${name.replace(/\s+/g, '')}() {\n${body}\n    }`,
+        beforeAll: (body) => `    @BeforeAll\n    static void setUpAll() {\n${body}\n    }`,
+        afterAll: (body) => `    @AfterAll\n    static void tearDownAll() {\n${body}\n    }`,
+        beforeEach: (body) => `    @BeforeEach\n    void setUp() {\n${body}\n    }`,
+        afterEach: (body) => `    @AfterEach\n    void tearDown() {\n${body}\n    }`,
+        expect: (value) => `assertEquals(${value}`,
+        mockFn: () => 'mock()',
+        mockModule: (module) => `// Mock ${module} with Mockito`,
+    },
+    nunit: {
+        imports: 'using NUnit.Framework;\nusing Moq;',
+        describe: (name, body) => `[TestFixture]\npublic class ${name.replace(/\s+/g, '')}Tests\n{\n${body}\n}`,
+        it: (name, body, _isAsync) => `    [Test]\n    public void Test${name.replace(/\s+/g, '')}()\n    {\n${body}\n    }`,
+        beforeAll: (body) => `    [OneTimeSetUp]\n    public void SetUpFixture()\n    {\n${body}\n    }`,
+        afterAll: (body) => `    [OneTimeTearDown]\n    public void TearDownFixture()\n    {\n${body}\n    }`,
+        beforeEach: (body) => `    [SetUp]\n    public void SetUp()\n    {\n${body}\n    }`,
+        afterEach: (body) => `    [TearDown]\n    public void TearDown()\n    {\n${body}\n    }`,
+        expect: (value) => `Assert.That(${value}`,
+        mockFn: () => 'new Mock<T>()',
+        mockModule: (module) => `// Mock ${module} with Moq`,
+    },
+    xunit: {
+        imports: 'using Xunit;\nusing Moq;',
+        describe: (name, body) => `public class ${name.replace(/\s+/g, '')}Tests\n{\n${body}\n}`,
+        it: (name, body, _isAsync) => `    [Fact]\n    public void Test${name.replace(/\s+/g, '')}()\n    {\n${body}\n    }`,
+        beforeAll: (body) => `    public XunitTests()\n    {\n${body}\n    }`,
+        afterAll: (body) => `    public void Dispose()\n    {\n${body}\n    }`,
+        beforeEach: (body) => `    // Setup: ${body}`,
+        afterEach: (body) => `    // Teardown: ${body}`,
+        expect: (value) => `Assert.Equal(${value}`,
+        mockFn: () => 'new Mock<T>()',
+        mockModule: (module) => `// Mock ${module} with Moq`,
+    },
+    'go-test': {
+        imports: 'import (\n    "testing"\n)',
+        describe: (name, body) => `// ${name}\n${body}`,
+        it: (name, body, _isAsync) => `func Test${name.replace(/\s+/g, '')}(t *testing.T) {\n${body}\n}`,
+        beforeAll: (body) => `func TestMain(m *testing.M) {\n${body}\n    os.Exit(m.Run())\n}`,
+        afterAll: (body) => `// Teardown in TestMain: ${body}`,
+        beforeEach: (body) => `    // Setup: ${body}`,
+        afterEach: (body) => `    // Teardown: ${body}`,
+        expect: (value) => `if ${value}`,
+        mockFn: () => '// mock function',
+        mockModule: (module) => `// Mock ${module}`,
+    },
+};
+/**
+ * Unit Test Generator
+ */
+export class UnitTestGenerator {
+    config;
+    template;
+    constructor(config) {
+        this.config = { ...DEFAULT_TEST_GENERATOR_CONFIG, ...config };
+        this.template = FRAMEWORK_TEMPLATES[this.config.framework];
+    }
+    /**
+     * Generate tests for a function
+     */
+    generateForFunction(func, targetFile) {
+        const testCases = this.generateTestCases(func);
+        const content = this.generateTestFile(func, testCases, targetFile);
+        const testFilePath = this.getTestFilePath(targetFile);
+        const coverageEstimate = this.estimateCoverage(func, testCases);
+        return {
+            content,
+            filePath: testFilePath,
+            testCount: testCases.length,
+            coverageEstimate,
+            warnings: this.generateWarnings(func, testCases),
+        };
+    }
+    /**
+     * Generate tests for multiple functions
+     */
+    generateForModule(functions, targetFile) {
+        const allTestCases = [];
+        const warnings = [];
+        for (const func of functions) {
+            const testCases = this.generateTestCases(func);
+            allTestCases.push(...testCases);
+            warnings.push(...this.generateWarnings(func, testCases));
+        }
+        const content = this.generateModuleTestFile(functions, allTestCases, targetFile);
+        const testFilePath = this.getTestFilePath(targetFile);
+        return {
+            content,
+            filePath: testFilePath,
+            testCount: allTestCases.length,
+            coverageEstimate: this.estimateModuleCoverage(functions, allTestCases),
+            warnings,
+        };
+    }
+    /**
+     * Generate test cases for a function
+     */
+    generateTestCases(func) {
+        const testCases = [];
+        // Basic happy path test
+        testCases.push(this.generateHappyPathTest(func));
+        // Edge cases
+        if (this.config.generateEdgeCases) {
+            testCases.push(...this.generateEdgeCaseTests(func));
+        }
+        // Error cases
+        if (this.config.generateErrorCases) {
+            testCases.push(...this.generateErrorTests(func));
+        }
+        // Null/undefined cases
+        if (this.config.generateNullCases) {
+            testCases.push(...this.generateNullTests(func));
+        }
+        // Limit test cases
+        return testCases.slice(0, this.config.maxTestCasesPerFunction);
+    }
+    /**
+     * Generate happy path test
+     */
+    generateHappyPathTest(func) {
+        return {
+            name: `should ${this.generateTestName(func)} with valid input`,
+            description: `Tests ${func.name} with typical valid input`,
+            type: 'unit',
+            inputs: func.parameters.map((p) => ({
+                name: p.name,
+                value: this.generateSampleValue(p.type),
+                type: p.type,
+            })),
+            expectedOutput: {
+                type: func.returnType,
+                value: this.generateExpectedValue(func.returnType),
+            },
+        };
+    }
+    /**
+     * Generate edge case tests
+     */
+    generateEdgeCaseTests(func) {
+        const tests = [];
+        for (const param of func.parameters) {
+            const edgeValues = this.getEdgeValues(param.type);
+            for (const edge of edgeValues) {
+                tests.push({
+                    name: `should handle ${param.name} with ${edge.description}`,
+                    description: `Edge case test for ${param.name}`,
+                    type: 'edge',
+                    inputs: func.parameters.map((p) => ({
+                        name: p.name,
+                        value: p.name === param.name ? edge.value : this.generateSampleValue(p.type),
+                        type: p.type,
+                    })),
+                    expectedOutput: {
+                        type: func.returnType,
+                    },
+                    tags: ['edge-case'],
+                });
+            }
+        }
+        return tests;
+    }
+    /**
+     * Generate error tests
+     */
+    generateErrorTests(func) {
+        const tests = [];
+        // Invalid type tests
+        for (const param of func.parameters) {
+            if (!param.optional) {
+                tests.push({
+                    name: `should throw error when ${param.name} is invalid`,
+                    description: `Error handling test for invalid ${param.name}`,
+                    type: 'error',
+                    inputs: func.parameters.map((p) => ({
+                        name: p.name,
+                        value: p.name === param.name ? this.generateInvalidValue(p.type) : this.generateSampleValue(p.type),
+                        type: p.type,
+                    })),
+                    expectedOutput: {
+                        error: {
+                            type: 'Error',
+                            message: `Invalid ${param.name}`,
+                        },
+                    },
+                    tags: ['error-handling'],
+                });
+            }
+        }
+        return tests;
+    }
+    /**
+     * Generate null/undefined tests
+     */
+    generateNullTests(func) {
+        const tests = [];
+        for (const param of func.parameters) {
+            if (!param.optional) {
+                // Null test
+                tests.push({
+                    name: `should handle null ${param.name}`,
+                    description: `Null handling test for ${param.name}`,
+                    type: 'null',
+                    inputs: func.parameters.map((p) => ({
+                        name: p.name,
+                        value: p.name === param.name ? null : this.generateSampleValue(p.type),
+                        type: p.type,
+                    })),
+                    expectedOutput: {
+                        error: {
+                            type: 'TypeError',
+                        },
+                    },
+                    tags: ['null-check'],
+                });
+                // Undefined test
+                tests.push({
+                    name: `should handle undefined ${param.name}`,
+                    description: `Undefined handling test for ${param.name}`,
+                    type: 'null',
+                    inputs: func.parameters.map((p) => ({
+                        name: p.name,
+                        value: p.name === param.name ? undefined : this.generateSampleValue(p.type),
+                        type: p.type,
+                    })),
+                    expectedOutput: {
+                        error: {
+                            type: 'TypeError',
+                        },
+                    },
+                    tags: ['undefined-check'],
+                });
+            }
+        }
+        return tests;
+    }
+    /**
+     * Generate test file content
+     */
+    generateTestFile(func, testCases, targetFile) {
+        const lines = [];
+        // Framework imports
+        if (this.template.imports) {
+            lines.push(this.template.imports);
+        }
+        // Import target
+        const importPath = this.getImportPath(targetFile);
+        lines.push(`import { ${func.name} } from '${importPath}';`);
+        lines.push('');
+        // Generate describe block
+        const testBody = this.generateDescribeBody(func, testCases);
+        lines.push(this.template.describe(func.name, testBody));
+        return lines.join('\n');
+    }
+    /**
+     * Generate module test file
+     */
+    generateModuleTestFile(functions, testCases, targetFile) {
+        const lines = [];
+        // Framework imports
+        if (this.template.imports) {
+            lines.push(this.template.imports);
+        }
+        // Import targets
+        const importPath = this.getImportPath(targetFile);
+        const imports = functions.map((f) => f.name).join(', ');
+        lines.push(`import { ${imports} } from '${importPath}';`);
+        lines.push('');
+        // Generate describe blocks for each function
+        for (const func of functions) {
+            const funcTests = testCases.filter((t) => t.name.includes(func.name) || t.description.includes(func.name));
+            const testBody = this.generateDescribeBody(func, funcTests);
+            lines.push(this.template.describe(func.name, testBody));
+            lines.push('');
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Generate describe block body
+     */
+    generateDescribeBody(func, testCases) {
+        const lines = [];
+        // Setup/teardown
+        if (this.config.includeSetupTeardown) {
+            lines.push(this.template.beforeEach('    // Setup'));
+            lines.push('');
+        }
+        // Test cases
+        for (const testCase of testCases) {
+            const testBody = this.generateTestBody(func, testCase);
+            lines.push(this.template.it(testCase.name, testBody, func.isAsync));
+            lines.push('');
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Generate test body
+     */
+    generateTestBody(func, testCase) {
+        const lines = [];
+        const indent = '    ';
+        // Setup mocks
+        if (testCase.mocks) {
+            for (const mock of testCase.mocks) {
+                lines.push(`${indent}const ${mock.target}Mock = ${this.template.mockFn()};`);
+            }
+        }
+        // Arrange: prepare inputs
+        const inputVars = [];
+        for (const input of testCase.inputs) {
+            const varName = input.name;
+            const value = JSON.stringify(input.value);
+            lines.push(`${indent}const ${varName} = ${value};`);
+            inputVars.push(varName);
+        }
+        lines.push('');
+        // Act: call function
+        const funcCall = func.className
+            ? `new ${func.className}().${func.name}(${inputVars.join(', ')})`
+            : `${func.name}(${inputVars.join(', ')})`;
+        if (testCase.expectedOutput.error) {
+            // Expect error
+            if (func.isAsync) {
+                lines.push(`${indent}await ${this.template.expect(`${funcCall}`)}.rejects.toThrow();`);
+            }
+            else {
+                lines.push(`${indent}${this.template.expect(`() => ${funcCall}`)}.toThrow();`);
+            }
+        }
+        else {
+            // Expect result
+            const resultVar = func.isAsync
+                ? `await ${funcCall}`
+                : funcCall;
+            lines.push(`${indent}const result = ${resultVar};`);
+            lines.push('');
+            // Assert
+            if (testCase.expectedOutput.value !== undefined) {
+                const expected = JSON.stringify(testCase.expectedOutput.value);
+                lines.push(`${indent}${this.template.expect('result')}.toEqual(${expected});`);
+            }
+            else {
+                lines.push(`${indent}${this.template.expect('result')}.toBeDefined();`);
+            }
+        }
+        return lines.join('\n');
+    }
+    /**
+     * Generate test name from function
+     */
+    generateTestName(func) {
+        // Convert camelCase to words
+        const words = func.name
+            .replace(/([A-Z])/g, ' $1')
+            .toLowerCase()
+            .trim();
+        return words;
+    }
+    /**
+     * Generate sample value for type
+     */
+    generateSampleValue(type) {
+        const normalized = type.toLowerCase().replace(/\s+/g, '');
+        if (normalized.includes('string'))
+            return 'test';
+        if (normalized.includes('number') || normalized.includes('int') || normalized.includes('float'))
+            return 42;
+        if (normalized.includes('boolean') || normalized.includes('bool'))
+            return true;
+        if (normalized.includes('array') || normalized.includes('[]'))
+            return [];
+        if (normalized.includes('object') || normalized.includes('record'))
+            return {};
+        if (normalized.includes('date'))
+            return new Date().toISOString();
+        if (normalized.includes('null'))
+            return null;
+        if (normalized.includes('undefined'))
+            return undefined;
+        return {};
+    }
+    /**
+     * Generate expected value for return type
+     */
+    generateExpectedValue(type) {
+        const normalized = type.toLowerCase().replace(/\s+/g, '');
+        if (normalized === 'void' || normalized === 'undefined')
+            return undefined;
+        if (normalized.includes('promise')) {
+            const inner = type.match(/<(.+)>/)?.[1] ?? 'unknown';
+            return this.generateSampleValue(inner);
+        }
+        return this.generateSampleValue(type);
+    }
+    /**
+     * Generate invalid value for type
+     */
+    generateInvalidValue(type) {
+        const normalized = type.toLowerCase().replace(/\s+/g, '');
+        if (normalized.includes('string'))
+            return 123;
+        if (normalized.includes('number'))
+            return 'not a number';
+        if (normalized.includes('boolean'))
+            return 'not boolean';
+        if (normalized.includes('array'))
+            return 'not array';
+        if (normalized.includes('object'))
+            return 'not object';
+        return Symbol('invalid');
+    }
+    /**
+     * Get edge values for type
+     */
+    getEdgeValues(type) {
+        const normalized = type.toLowerCase().replace(/\s+/g, '');
+        const edges = [];
+        if (normalized.includes('string')) {
+            edges.push({ value: '', description: 'empty string' });
+            edges.push({ value: ' ', description: 'whitespace' });
+            edges.push({ value: 'a'.repeat(1000), description: 'very long string' });
+        }
+        if (normalized.includes('number')) {
+            edges.push({ value: 0, description: 'zero' });
+            edges.push({ value: -1, description: 'negative' });
+            edges.push({ value: Number.MAX_SAFE_INTEGER, description: 'max safe integer' });
+            edges.push({ value: Number.MIN_SAFE_INTEGER, description: 'min safe integer' });
+            edges.push({ value: Infinity, description: 'infinity' });
+            edges.push({ value: NaN, description: 'NaN' });
+        }
+        if (normalized.includes('array')) {
+            edges.push({ value: [], description: 'empty array' });
+            edges.push({ value: new Array(1000).fill(0), description: 'large array' });
+        }
+        return edges;
+    }
+    /**
+     * Get test file path
+     */
+    getTestFilePath(targetFile) {
+        const parts = targetFile.split('/');
+        const filename = parts.pop();
+        const ext = filename.split('.').pop();
+        const baseName = filename.replace(`.${ext}`, '');
+        return [...parts, this.config.testDirectory, `${baseName}${this.config.testFileSuffix}.${ext}`].join('/');
+    }
+    /**
+     * Get import path
+     */
+    getImportPath(targetFile) {
+        // Convert absolute to relative import
+        const parts = targetFile.split('/');
+        const filename = parts.pop();
+        const ext = filename.split('.').pop();
+        const baseName = filename.replace(`.${ext}`, '');
+        return `../${baseName}`;
+    }
+    /**
+     * Estimate coverage
+     */
+    estimateCoverage(_func, testCases) {
+        const hasHappyPath = testCases.some((t) => t.type === 'unit');
+        const hasEdgeCases = testCases.some((t) => t.type === 'edge');
+        const hasErrorCases = testCases.some((t) => t.type === 'error');
+        const hasNullCases = testCases.some((t) => t.type === 'null');
+        let base = hasHappyPath ? 50 : 0;
+        if (hasEdgeCases)
+            base += 15;
+        if (hasErrorCases)
+            base += 20;
+        if (hasNullCases)
+            base += 15;
+        return {
+            statements: Math.min(base + 10, 100),
+            branches: Math.min(base, 100),
+            functions: hasHappyPath ? 100 : 0,
+            lines: Math.min(base + 10, 100),
+        };
+    }
+    /**
+     * Estimate module coverage
+     */
+    estimateModuleCoverage(functions, testCases) {
+        const functionsCovered = functions.filter((f) => testCases.some((t) => t.name.includes(f.name) || t.description.includes(f.name))).length;
+        const functionCoverage = functions.length > 0
+            ? (functionsCovered / functions.length) * 100
+            : 0;
+        return {
+            statements: Math.round(functionCoverage * 0.9),
+            branches: Math.round(functionCoverage * 0.7),
+            functions: Math.round(functionCoverage),
+            lines: Math.round(functionCoverage * 0.9),
+        };
+    }
+    /**
+     * Generate warnings
+     */
+    generateWarnings(func, testCases) {
+        const warnings = [];
+        if (testCases.length < 3) {
+            warnings.push(`Low test count for ${func.name}: consider adding more test cases`);
+        }
+        if (func.parameters.length > 5) {
+            warnings.push(`${func.name} has many parameters: consider refactoring`);
+        }
+        if (!testCases.some((t) => t.type === 'error')) {
+            warnings.push(`No error handling tests for ${func.name}`);
+        }
+        return warnings;
+    }
+}
+/**
+ * Create unit test generator instance
+ */
+export function createUnitTestGenerator(config) {
+    return new UnitTestGenerator(config);
+}
+//# sourceMappingURL=unit-test-generator.js.map