aigroup-workflow 2.2.1 → 2.2.2

package/skills/quality/tdd-guide/scripts/test_generator.py

@@ -1,438 +1,438 @@
-"""
-Test case generation module.
-
-Generates test cases from requirements, user stories, API specs, and code analysis.
-Supports multiple testing frameworks with intelligent test scaffolding.
-"""
-
-from typing import Dict, List, Any, Optional
-from enum import Enum
-
-
-class TestFramework(Enum):
-    """Supported testing frameworks."""
-    JEST = "jest"
-    VITEST = "vitest"
-    PYTEST = "pytest"
-    JUNIT = "junit"
-    MOCHA = "mocha"
-
-
-class TestType(Enum):
-    """Types of tests to generate."""
-    UNIT = "unit"
-    INTEGRATION = "integration"
-    E2E = "e2e"
-
-
-class TestGenerator:
-    """Generate test cases and test stubs from requirements and code."""
-
-    def __init__(self, framework: TestFramework, language: str):
-        """
-        Initialize test generator.
-
-        Args:
-            framework: Testing framework to use
-            language: Programming language (typescript, javascript, python, java)
-        """
-        self.framework = framework
-        self.language = language
-        self.test_cases = []
-
-    def generate_from_requirements(
-        self,
-        requirements: Dict[str, Any],
-        test_type: TestType = TestType.UNIT
-    ) -> List[Dict[str, Any]]:
-        """
-        Generate test cases from requirements.
-
-        Args:
-            requirements: Dictionary with user_stories, acceptance_criteria, api_specs
-            test_type: Type of tests to generate
-
-        Returns:
-            List of test case specifications
-        """
-        test_cases = []
-
-        # Generate from user stories
-        if 'user_stories' in requirements:
-            for story in requirements['user_stories']:
-                test_cases.extend(self._test_cases_from_story(story))
-
-        # Generate from acceptance criteria
-        if 'acceptance_criteria' in requirements:
-            for criterion in requirements['acceptance_criteria']:
-                test_cases.extend(self._test_cases_from_criteria(criterion))
-
-        # Generate from API specs
-        if 'api_specs' in requirements:
-            for endpoint in requirements['api_specs']:
-                test_cases.extend(self._test_cases_from_api(endpoint))
-
-        self.test_cases = test_cases
-        return test_cases
-
-    def _test_cases_from_story(self, story: Dict[str, Any]) -> List[Dict[str, Any]]:
-        """Generate test cases from user story."""
-        test_cases = []
-
-        # Happy path test
-        test_cases.append({
-            'name': f"should_{story.get('action', 'work')}_successfully",
-            'type': 'happy_path',
-            'description': story.get('description', ''),
-            'given': story.get('given', []),
-            'when': story.get('when', ''),
-            'then': story.get('then', ''),
-            'priority': 'P0'
-        })
-
-        # Error cases
-        if 'error_conditions' in story:
-            for error in story['error_conditions']:
-                test_cases.append({
-                    'name': f"should_handle_{error.get('condition', 'error')}",
-                    'type': 'error_case',
-                    'description': error.get('description', ''),
-                    'expected_error': error.get('error_type', ''),
-                    'priority': 'P0'
-                })
-
-        # Edge cases
-        if 'edge_cases' in story:
-            for edge_case in story['edge_cases']:
-                test_cases.append({
-                    'name': f"should_handle_{edge_case.get('scenario', 'edge_case')}",
-                    'type': 'edge_case',
-                    'description': edge_case.get('description', ''),
-                    'priority': 'P1'
-                })
-
-        return test_cases
-
-    def _test_cases_from_criteria(self, criterion: Dict[str, Any]) -> List[Dict[str, Any]]:
-        """Generate test cases from acceptance criteria."""
-        return [{
-            'name': f"should_meet_{criterion.get('id', 'criterion')}",
-            'type': 'acceptance',
-            'description': criterion.get('description', ''),
-            'verification': criterion.get('verification_steps', []),
-            'priority': 'P0'
-        }]
-
-    def _test_cases_from_api(self, endpoint: Dict[str, Any]) -> List[Dict[str, Any]]:
-        """Generate test cases from API specification."""
-        test_cases = []
-        method = endpoint.get('method', 'GET')
-        path = endpoint.get('path', '/')
-
-        # Success case
-        test_cases.append({
-            'name': f"should_{method.lower()}_{path.replace('/', '_')}_successfully",
-            'type': 'api_success',
-            'method': method,
-            'path': path,
-            'expected_status': endpoint.get('success_status', 200),
-            'priority': 'P0'
-        })
-
-        # Validation errors
-        if 'required_params' in endpoint:
-            test_cases.append({
-                'name': f"should_return_400_for_missing_params",
-                'type': 'api_validation',
-                'method': method,
-                'path': path,
-                'expected_status': 400,
-                'priority': 'P0'
-            })
-
-        # Authorization
-        if endpoint.get('requires_auth', False):
-            test_cases.append({
-                'name': f"should_return_401_for_unauthenticated",
-                'type': 'api_auth',
-                'method': method,
-                'path': path,
-                'expected_status': 401,
-                'priority': 'P0'
-            })
-
-        return test_cases
-
-    def generate_test_stub(self, test_case: Dict[str, Any]) -> str:
-        """
-        Generate test stub code for a test case.
-
-        Args:
-            test_case: Test case specification
-
-        Returns:
-            Test stub code as string
-        """
-        if self.framework == TestFramework.JEST:
-            return self._generate_jest_stub(test_case)
-        elif self.framework == TestFramework.PYTEST:
-            return self._generate_pytest_stub(test_case)
-        elif self.framework == TestFramework.JUNIT:
-            return self._generate_junit_stub(test_case)
-        elif self.framework == TestFramework.VITEST:
-            return self._generate_vitest_stub(test_case)
-        else:
-            return self._generate_generic_stub(test_case)
-
-    def _generate_jest_stub(self, test_case: Dict[str, Any]) -> str:
-        """Generate Jest test stub."""
-        name = test_case.get('name', 'test')
-        description = test_case.get('description', '')
-
-        stub = f"""
-describe('{{Feature Name}}', () => {{
-  it('{name}', () => {{
-    // {description}
-
-    // Arrange
-    // TODO: Set up test data and dependencies
-
-    // Act
-    // TODO: Execute the code under test
-
-    // Assert
-    // TODO: Verify expected behavior
-    expect(true).toBe(true); // Replace with actual assertion
-  }});
-}});
-"""
-        return stub.strip()
-
-    def _generate_pytest_stub(self, test_case: Dict[str, Any]) -> str:
-        """Generate Pytest test stub."""
-        name = test_case.get('name', 'test')
-        description = test_case.get('description', '')
-
-        stub = f"""
-def test_{name}():
-    \"\"\"
-    {description}
-    \"\"\"
-    # Arrange
-    # TODO: Set up test data and dependencies
-
-    # Act
-    # TODO: Execute the code under test
-
-    # Assert
-    # TODO: Verify expected behavior
-    assert True  # Replace with actual assertion
-"""
-        return stub.strip()
-
-    def _generate_junit_stub(self, test_case: Dict[str, Any]) -> str:
-        """Generate JUnit test stub."""
-        name = test_case.get('name', 'test')
-        description = test_case.get('description', '')
-
-        # Convert snake_case to camelCase for Java
-        method_name = ''.join(word.capitalize() if i > 0 else word
-                             for i, word in enumerate(name.split('_')))
-
-        stub = f"""
-@Test
-public void {method_name}() {{
-    // {description}
-
-    // Arrange
-    // TODO: Set up test data and dependencies
-
-    // Act
-    // TODO: Execute the code under test
-
-    // Assert
-    // TODO: Verify expected behavior
-    assertTrue(true); // Replace with actual assertion
-}}
-"""
-        return stub.strip()
-
-    def _generate_vitest_stub(self, test_case: Dict[str, Any]) -> str:
-        """Generate Vitest test stub (similar to Jest)."""
-        name = test_case.get('name', 'test')
-        description = test_case.get('description', '')
-
-        stub = f"""
-describe('{{Feature Name}}', () => {{
-  it('{name}', () => {{
-    // {description}
-
-    // Arrange
-    // TODO: Set up test data and dependencies
-
-    // Act
-    // TODO: Execute the code under test
-
-    // Assert
-    // TODO: Verify expected behavior
-    expect(true).toBe(true); // Replace with actual assertion
-  }});
-}});
-"""
-        return stub.strip()
-
-    def _generate_generic_stub(self, test_case: Dict[str, Any]) -> str:
-        """Generate generic test stub."""
-        name = test_case.get('name', 'test')
-        description = test_case.get('description', '')
-
-        return f"""
-# Test: {name}
-# Description: {description}
-#
-# TODO: Implement test
-# 1. Arrange: Set up test data
-# 2. Act: Execute code under test
-# 3. Assert: Verify expected behavior
-"""
-
-    def generate_test_file(
-        self,
-        module_name: str,
-        test_cases: Optional[List[Dict[str, Any]]] = None
-    ) -> str:
-        """
-        Generate complete test file with all test stubs.
-
-        Args:
-            module_name: Name of module being tested
-            test_cases: List of test cases (uses self.test_cases if not provided)
-
-        Returns:
-            Complete test file content
-        """
-        cases = test_cases or self.test_cases
-
-        if self.framework == TestFramework.JEST:
-            return self._generate_jest_file(module_name, cases)
-        elif self.framework == TestFramework.PYTEST:
-            return self._generate_pytest_file(module_name, cases)
-        elif self.framework == TestFramework.JUNIT:
-            return self._generate_junit_file(module_name, cases)
-        elif self.framework == TestFramework.VITEST:
-            return self._generate_vitest_file(module_name, cases)
-        else:
-            return ""
-
-    def _generate_jest_file(self, module_name: str, test_cases: List[Dict[str, Any]]) -> str:
-        """Generate complete Jest test file."""
-        imports = f"import {{ {module_name} }} from '../{module_name}';\n\n"
-
-        stubs = []
-        for test_case in test_cases:
-            stubs.append(self._generate_jest_stub(test_case))
-
-        return imports + "\n\n".join(stubs)
-
-    def _generate_pytest_file(self, module_name: str, test_cases: List[Dict[str, Any]]) -> str:
-        """Generate complete Pytest test file."""
-        imports = f"import pytest\nfrom {module_name} import *\n\n\n"
-
-        stubs = []
-        for test_case in test_cases:
-            stubs.append(self._generate_pytest_stub(test_case))
-
-        return imports + "\n\n\n".join(stubs)
-
-    def _generate_junit_file(self, module_name: str, test_cases: List[Dict[str, Any]]) -> str:
-        """Generate complete JUnit test file."""
-        class_name = ''.join(word.capitalize() for word in module_name.split('_'))
-
-        imports = """import org.junit.jupiter.api.Test;
-import static org.junit.jupiter.api.Assertions.*;
-
-"""
-
-        class_header = f"public class {class_name}Test {{\n\n"
-
-        stubs = []
-        for test_case in test_cases:
-            stubs.append(self._generate_junit_stub(test_case))
-
-        class_footer = "\n}"
-
-        return imports + class_header + "\n\n".join(stubs) + class_footer
-
-    def _generate_vitest_file(self, module_name: str, test_cases: List[Dict[str, Any]]) -> str:
-        """Generate complete Vitest test file."""
-        imports = f"import {{ describe, it, expect }} from 'vitest';\nimport {{ {module_name} }} from '../{module_name}';\n\n"
-
-        stubs = []
-        for test_case in test_cases:
-            stubs.append(self._generate_vitest_stub(test_case))
-
-        return imports + "\n\n".join(stubs)
-
-    def suggest_missing_scenarios(
-        self,
-        existing_tests: List[str],
-        code_analysis: Dict[str, Any]
-    ) -> List[Dict[str, Any]]:
-        """
-        Suggest missing test scenarios based on code analysis.
-
-        Args:
-            existing_tests: List of existing test names
-            code_analysis: Analysis of code under test (branches, error paths, etc.)
-
-        Returns:
-            List of suggested test scenarios
-        """
-        suggestions = []
-
-        # Check for untested error conditions
-        if 'error_handlers' in code_analysis:
-            for error_handler in code_analysis['error_handlers']:
-                error_name = error_handler.get('type', 'error')
-                if not self._has_test_for(existing_tests, error_name):
-                    suggestions.append({
-                        'name': f"should_handle_{error_name}",
-                        'type': 'error_case',
-                        'reason': 'Error handler exists but no corresponding test',
-                        'priority': 'P0'
-                    })
-
-        # Check for untested branches
-        if 'conditional_branches' in code_analysis:
-            for branch in code_analysis['conditional_branches']:
-                branch_name = branch.get('condition', 'condition')
-                if not self._has_test_for(existing_tests, branch_name):
-                    suggestions.append({
-                        'name': f"should_test_{branch_name}_branch",
-                        'type': 'branch_coverage',
-                        'reason': 'Conditional branch not fully tested',
-                        'priority': 'P1'
-                    })
-
-        # Check for boundary conditions
-        if 'input_validation' in code_analysis:
-            for validation in code_analysis['input_validation']:
-                param = validation.get('parameter', 'input')
-                if not self._has_test_for(existing_tests, f"{param}_boundary"):
-                    suggestions.append({
-                        'name': f"should_test_{param}_boundary_values",
-                        'type': 'boundary',
-                        'reason': 'Input validation exists but boundary tests missing',
-                        'priority': 'P1'
-                    })
-
-        return suggestions
-
-    def _has_test_for(self, existing_tests: List[str], keyword: str) -> bool:
-        """Check if existing tests cover a keyword/scenario."""
-        keyword_lower = keyword.lower().replace('_', '').replace('-', '')
-        for test in existing_tests:
-            test_lower = test.lower().replace('_', '').replace('-', '')
-            if keyword_lower in test_lower:
-                return True
-        return False
+"""
+Test case generation module.
+
+Generates test cases from requirements, user stories, API specs, and code analysis.
+Supports multiple testing frameworks with intelligent test scaffolding.
+"""
+
+from typing import Dict, List, Any, Optional
+from enum import Enum
+
+
+class TestFramework(Enum):
+    """Supported testing frameworks."""
+    JEST = "jest"
+    VITEST = "vitest"
+    PYTEST = "pytest"
+    JUNIT = "junit"
+    MOCHA = "mocha"
+
+
+class TestType(Enum):
+    """Types of tests to generate."""
+    UNIT = "unit"
+    INTEGRATION = "integration"
+    E2E = "e2e"
+
+
+class TestGenerator:
+    """Generate test cases and test stubs from requirements and code."""
+
+    def __init__(self, framework: TestFramework, language: str):
+        """
+        Initialize test generator.
+
+        Args:
+            framework: Testing framework to use
+            language: Programming language (typescript, javascript, python, java)
+        """
+        self.framework = framework
+        self.language = language
+        self.test_cases = []
+
+    def generate_from_requirements(
+        self,
+        requirements: Dict[str, Any],
+        test_type: TestType = TestType.UNIT
+    ) -> List[Dict[str, Any]]:
+        """
+        Generate test cases from requirements.
+
+        Args:
+            requirements: Dictionary with user_stories, acceptance_criteria, api_specs
+            test_type: Type of tests to generate
+
+        Returns:
+            List of test case specifications
+        """
+        test_cases = []
+
+        # Generate from user stories
+        if 'user_stories' in requirements:
+            for story in requirements['user_stories']:
+                test_cases.extend(self._test_cases_from_story(story))
+
+        # Generate from acceptance criteria
+        if 'acceptance_criteria' in requirements:
+            for criterion in requirements['acceptance_criteria']:
+                test_cases.extend(self._test_cases_from_criteria(criterion))
+
+        # Generate from API specs
+        if 'api_specs' in requirements:
+            for endpoint in requirements['api_specs']:
+                test_cases.extend(self._test_cases_from_api(endpoint))
+
+        self.test_cases = test_cases
+        return test_cases
+
+    def _test_cases_from_story(self, story: Dict[str, Any]) -> List[Dict[str, Any]]:
+        """Generate test cases from user story."""
+        test_cases = []
+
+        # Happy path test
+        test_cases.append({
+            'name': f"should_{story.get('action', 'work')}_successfully",
+            'type': 'happy_path',
+            'description': story.get('description', ''),
+            'given': story.get('given', []),
+            'when': story.get('when', ''),
+            'then': story.get('then', ''),
+            'priority': 'P0'
+        })
+
+        # Error cases
+        if 'error_conditions' in story:
+            for error in story['error_conditions']:
+                test_cases.append({
+                    'name': f"should_handle_{error.get('condition', 'error')}",
+                    'type': 'error_case',
+                    'description': error.get('description', ''),
+                    'expected_error': error.get('error_type', ''),
+                    'priority': 'P0'
+                })
+
+        # Edge cases
+        if 'edge_cases' in story:
+            for edge_case in story['edge_cases']:
+                test_cases.append({
+                    'name': f"should_handle_{edge_case.get('scenario', 'edge_case')}",
+                    'type': 'edge_case',
+                    'description': edge_case.get('description', ''),
+                    'priority': 'P1'
+                })
+
+        return test_cases
+
+    def _test_cases_from_criteria(self, criterion: Dict[str, Any]) -> List[Dict[str, Any]]:
+        """Generate test cases from acceptance criteria."""
+        return [{
+            'name': f"should_meet_{criterion.get('id', 'criterion')}",
+            'type': 'acceptance',
+            'description': criterion.get('description', ''),
+            'verification': criterion.get('verification_steps', []),
+            'priority': 'P0'
+        }]
+
+    def _test_cases_from_api(self, endpoint: Dict[str, Any]) -> List[Dict[str, Any]]:
+        """Generate test cases from API specification."""
+        test_cases = []
+        method = endpoint.get('method', 'GET')
+        path = endpoint.get('path', '/')
+
+        # Success case
+        test_cases.append({
+            'name': f"should_{method.lower()}_{path.replace('/', '_')}_successfully",
+            'type': 'api_success',
+            'method': method,
+            'path': path,
+            'expected_status': endpoint.get('success_status', 200),
+            'priority': 'P0'
+        })
+
+        # Validation errors
+        if 'required_params' in endpoint:
+            test_cases.append({
+                'name': f"should_return_400_for_missing_params",
+                'type': 'api_validation',
+                'method': method,
+                'path': path,
+                'expected_status': 400,
+                'priority': 'P0'
+            })
+
+        # Authorization
+        if endpoint.get('requires_auth', False):
+            test_cases.append({
+                'name': f"should_return_401_for_unauthenticated",
+                'type': 'api_auth',
+                'method': method,
+                'path': path,
+                'expected_status': 401,
+                'priority': 'P0'
+            })
+
+        return test_cases
+
+    def generate_test_stub(self, test_case: Dict[str, Any]) -> str:
+        """
+        Generate test stub code for a test case.
+
+        Args:
+            test_case: Test case specification
+
+        Returns:
+            Test stub code as string
+        """
+        if self.framework == TestFramework.JEST:
+            return self._generate_jest_stub(test_case)
+        elif self.framework == TestFramework.PYTEST:
+            return self._generate_pytest_stub(test_case)
+        elif self.framework == TestFramework.JUNIT:
+            return self._generate_junit_stub(test_case)
+        elif self.framework == TestFramework.VITEST:
+            return self._generate_vitest_stub(test_case)
+        else:
+            return self._generate_generic_stub(test_case)
+
+    def _generate_jest_stub(self, test_case: Dict[str, Any]) -> str:
+        """Generate Jest test stub."""
+        name = test_case.get('name', 'test')
+        description = test_case.get('description', '')
+
+        stub = f"""
+describe('{{Feature Name}}', () => {{
+  it('{name}', () => {{
+    // {description}
+
+    // Arrange
+    // TODO: Set up test data and dependencies
+
+    // Act
+    // TODO: Execute the code under test
+
+    // Assert
+    // TODO: Verify expected behavior
+    expect(true).toBe(true); // Replace with actual assertion
+  }});
+}});
+"""
+        return stub.strip()
+
+    def _generate_pytest_stub(self, test_case: Dict[str, Any]) -> str:
+        """Generate Pytest test stub."""
+        name = test_case.get('name', 'test')
+        description = test_case.get('description', '')
+
+        stub = f"""
+def test_{name}():
+    \"\"\"
+    {description}
+    \"\"\"
+    # Arrange
+    # TODO: Set up test data and dependencies
+
+    # Act
+    # TODO: Execute the code under test
+
+    # Assert
+    # TODO: Verify expected behavior
+    assert True  # Replace with actual assertion
+"""
+        return stub.strip()
+
+    def _generate_junit_stub(self, test_case: Dict[str, Any]) -> str:
+        """Generate JUnit test stub."""
+        name = test_case.get('name', 'test')
+        description = test_case.get('description', '')
+
+        # Convert snake_case to camelCase for Java
+        method_name = ''.join(word.capitalize() if i > 0 else word
+                             for i, word in enumerate(name.split('_')))
+
+        stub = f"""
+@Test
+public void {method_name}() {{
+    // {description}
+
+    // Arrange
+    // TODO: Set up test data and dependencies
+
+    // Act
+    // TODO: Execute the code under test
+
+    // Assert
+    // TODO: Verify expected behavior
+    assertTrue(true); // Replace with actual assertion
+}}
+"""
+        return stub.strip()
+
+    def _generate_vitest_stub(self, test_case: Dict[str, Any]) -> str:
+        """Generate Vitest test stub (similar to Jest)."""
+        name = test_case.get('name', 'test')
+        description = test_case.get('description', '')
+
+        stub = f"""
+describe('{{Feature Name}}', () => {{
+  it('{name}', () => {{
+    // {description}
+
+    // Arrange
+    // TODO: Set up test data and dependencies
+
+    // Act
+    // TODO: Execute the code under test
+
+    // Assert
+    // TODO: Verify expected behavior
+    expect(true).toBe(true); // Replace with actual assertion
+  }});
+}});
+"""
+        return stub.strip()
+
+    def _generate_generic_stub(self, test_case: Dict[str, Any]) -> str:
+        """Generate generic test stub."""
+        name = test_case.get('name', 'test')
+        description = test_case.get('description', '')
+
+        return f"""
+# Test: {name}
+# Description: {description}
+#
+# TODO: Implement test
+# 1. Arrange: Set up test data
+# 2. Act: Execute code under test
+# 3. Assert: Verify expected behavior
+"""
+
+    def generate_test_file(
+        self,
+        module_name: str,
+        test_cases: Optional[List[Dict[str, Any]]] = None
+    ) -> str:
+        """
+        Generate complete test file with all test stubs.
+
+        Args:
+            module_name: Name of module being tested
+            test_cases: List of test cases (uses self.test_cases if not provided)
+
+        Returns:
+            Complete test file content
+        """
+        cases = test_cases or self.test_cases
+
+        if self.framework == TestFramework.JEST:
+            return self._generate_jest_file(module_name, cases)
+        elif self.framework == TestFramework.PYTEST:
+            return self._generate_pytest_file(module_name, cases)
+        elif self.framework == TestFramework.JUNIT:
+            return self._generate_junit_file(module_name, cases)
+        elif self.framework == TestFramework.VITEST:
+            return self._generate_vitest_file(module_name, cases)
+        else:
+            return ""
+
+    def _generate_jest_file(self, module_name: str, test_cases: List[Dict[str, Any]]) -> str:
+        """Generate complete Jest test file."""
+        imports = f"import {{ {module_name} }} from '../{module_name}';\n\n"
+
+        stubs = []
+        for test_case in test_cases:
+            stubs.append(self._generate_jest_stub(test_case))
+
+        return imports + "\n\n".join(stubs)
+
+    def _generate_pytest_file(self, module_name: str, test_cases: List[Dict[str, Any]]) -> str:
+        """Generate complete Pytest test file."""
+        imports = f"import pytest\nfrom {module_name} import *\n\n\n"
+
+        stubs = []
+        for test_case in test_cases:
+            stubs.append(self._generate_pytest_stub(test_case))
+
+        return imports + "\n\n\n".join(stubs)
+
+    def _generate_junit_file(self, module_name: str, test_cases: List[Dict[str, Any]]) -> str:
+        """Generate complete JUnit test file."""
+        class_name = ''.join(word.capitalize() for word in module_name.split('_'))
+
+        imports = """import org.junit.jupiter.api.Test;
+import static org.junit.jupiter.api.Assertions.*;
+
+"""
+
+        class_header = f"public class {class_name}Test {{\n\n"
+
+        stubs = []
+        for test_case in test_cases:
+            stubs.append(self._generate_junit_stub(test_case))
+
+        class_footer = "\n}"
+
+        return imports + class_header + "\n\n".join(stubs) + class_footer
+
+    def _generate_vitest_file(self, module_name: str, test_cases: List[Dict[str, Any]]) -> str:
+        """Generate complete Vitest test file."""
+        imports = f"import {{ describe, it, expect }} from 'vitest';\nimport {{ {module_name} }} from '../{module_name}';\n\n"
+
+        stubs = []
+        for test_case in test_cases:
+            stubs.append(self._generate_vitest_stub(test_case))
+
+        return imports + "\n\n".join(stubs)
+
+    def suggest_missing_scenarios(
+        self,
+        existing_tests: List[str],
+        code_analysis: Dict[str, Any]
+    ) -> List[Dict[str, Any]]:
+        """
+        Suggest missing test scenarios based on code analysis.
+
+        Args:
+            existing_tests: List of existing test names
+            code_analysis: Analysis of code under test (branches, error paths, etc.)
+
+        Returns:
+            List of suggested test scenarios
+        """
+        suggestions = []
+
+        # Check for untested error conditions
+        if 'error_handlers' in code_analysis:
+            for error_handler in code_analysis['error_handlers']:
+                error_name = error_handler.get('type', 'error')
+                if not self._has_test_for(existing_tests, error_name):
+                    suggestions.append({
+                        'name': f"should_handle_{error_name}",
+                        'type': 'error_case',
+                        'reason': 'Error handler exists but no corresponding test',
+                        'priority': 'P0'
+                    })
+
+        # Check for untested branches
+        if 'conditional_branches' in code_analysis:
+            for branch in code_analysis['conditional_branches']:
+                branch_name = branch.get('condition', 'condition')
+                if not self._has_test_for(existing_tests, branch_name):
+                    suggestions.append({
+                        'name': f"should_test_{branch_name}_branch",
+                        'type': 'branch_coverage',
+                        'reason': 'Conditional branch not fully tested',
+                        'priority': 'P1'
+                    })
+
+        # Check for boundary conditions
+        if 'input_validation' in code_analysis:
+            for validation in code_analysis['input_validation']:
+                param = validation.get('parameter', 'input')
+                if not self._has_test_for(existing_tests, f"{param}_boundary"):
+                    suggestions.append({
+                        'name': f"should_test_{param}_boundary_values",
+                        'type': 'boundary',
+                        'reason': 'Input validation exists but boundary tests missing',
+                        'priority': 'P1'
+                    })
+
+        return suggestions
+
+    def _has_test_for(self, existing_tests: List[str], keyword: str) -> bool:
+        """Check if existing tests cover a keyword/scenario."""
+        keyword_lower = keyword.lower().replace('_', '').replace('-', '')
+        for test in existing_tests:
+            test_lower = test.lower().replace('_', '').replace('-', '')
+            if keyword_lower in test_lower:
+                return True
+        return False