@voodocs/cli 0.1.0

package/lib/darkarts/plugins/voodocs/test_generator.py

@@ -0,0 +1,636 @@
+"""
+VooDocs Test Generator
+
+Generates automated test cases from @voodocs annotations, including property-based tests.
+"""
+
+from typing import List, Optional, Dict, Any, Tuple
+from pathlib import Path
+import re
+
+from darkarts.annotations.types import (
+    ParsedAnnotations,
+    FunctionAnnotation,
+    ClassAnnotation,
+)
+
+
+class TestGenerator:
+    """Generates test cases from @voodocs annotations."""
+    
+    def __init__(self, framework: str = "pytest"):
+        """
+        Initialize test generator.
+        
+        Args:
+            framework: Test framework to use ("pytest", "unittest", "jest", "junit")
+        """
+        self.framework = framework
+    
+    def generate(self, parsed: ParsedAnnotations, output_file: Optional[str] = None) -> str:
+        """Generate test cases from parsed annotations."""
+        if not parsed.has_annotations():
+            return self._generate_empty_test(parsed)
+        
+        if self.framework == "pytest":
+            return self._generate_pytest(parsed, output_file)
+        elif self.framework == "unittest":
+            return self._generate_unittest(parsed, output_file)
+        elif self.framework == "jest":
+            return self._generate_jest(parsed, output_file)
+        else:
+            raise ValueError(f"Unsupported test framework: {self.framework}")
+    
+    def _generate_empty_test(self, parsed: ParsedAnnotations) -> str:
+        """Generate empty test file for code without annotations."""
+        return f"""# No @voodocs annotations found in {parsed.module.name}
+# Cannot generate automated tests without annotations
+"""
+    
+    def _generate_pytest(self, parsed: ParsedAnnotations, output_file: Optional[str] = None) -> str:
+        """Generate pytest test cases with property-based testing."""
+        lines = []
+        
+        # Header
+        lines.append('"""')
+        lines.append(f"Automated tests for {parsed.module.name}")
+        lines.append("Generated from @voodocs annotations")
+        lines.append('"""')
+        lines.append("")
+        lines.append("import pytest")
+        lines.append("from hypothesis import given, strategies as st, assume")
+        lines.append("from hypothesis import settings, HealthCheck")
+        lines.append(f"from {parsed.module.name} import *")
+        lines.append("")
+        lines.append("")
+        
+        # Generate tests for each function
+        all_functions = parsed.get_all_functions()
+        for func in all_functions:
+            lines.extend(self._generate_pytest_function_tests(func))
+            lines.append("")
+        
+        # Generate tests for each class
+        for cls in parsed.module.classes:
+            lines.extend(self._generate_pytest_class_tests(cls))
+            lines.append("")
+        
+        test_code = "\n".join(lines)
+        
+        if output_file:
+            output_path = Path(output_file)
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+            output_path.write_text(test_code, encoding='utf-8')
+        
+        return test_code
+    
+    def _generate_pytest_function_tests(self, func: FunctionAnnotation) -> List[str]:
+        """Generate pytest tests for a function with property-based testing."""
+        lines = []
+        
+        # Test class for the function
+        test_class_name = f"Test{func.name.replace('_', ' ').title().replace(' ', '')}"
+        lines.append(f"class {test_class_name}:")
+        lines.append(f'    """Tests for {func.name}()"""')
+        lines.append("")
+        
+        # Property-based test for preconditions and postconditions
+        if func.preconditions or func.postconditions:
+            lines.extend(self._generate_property_based_test(func))
+            lines.append("")
+        
+        # Test preconditions enforcement
+        if func.preconditions:
+            lines.extend(self._generate_precondition_tests(func))
+            lines.append("")
+        
+        # Test postconditions
+        if func.postconditions:
+            lines.extend(self._generate_postcondition_tests(func))
+            lines.append("")
+        
+        # Test invariants
+        if func.invariants:
+            lines.extend(self._generate_invariant_tests(func))
+            lines.append("")
+        
+        # Test error cases
+        if func.error_cases:
+            lines.extend(self._generate_error_case_tests(func))
+            lines.append("")
+        
+        # Test edge cases
+        lines.extend(self._generate_edge_case_tests(func))
+        lines.append("")
+        
+        # Test complexity/performance
+        if func.complexity:
+            lines.extend(self._generate_performance_test(func))
+            lines.append("")
+        
+        # Happy path test
+        lines.extend(self._generate_happy_path_test(func))
+        
+        return lines
+    
+    def _generate_property_based_test(self, func: FunctionAnnotation) -> List[str]:
+        """Generate property-based test using Hypothesis."""
+        lines = []
+        
+        # Infer input strategies from preconditions
+        strategies = self._infer_strategies_from_preconditions(func.preconditions)
+        
+        # Build @given decorator
+        if strategies:
+            strategy_params = ", ".join([f"{name}={strat}" for name, strat in strategies.items()])
+            lines.append(f"    @given({strategy_params})")
+            lines.append("    @settings(suppress_health_check=[HealthCheck.function_scoped_fixture])")
+        else:
+            # Generic strategy if we can't infer
+            lines.append("    @given(st.data())")
+        
+        lines.append(f"    def test_property_based_{func.name}(self{', ' + ', '.join(strategies.keys()) if strategies else ', data'}):")
+        lines.append(f'        """Property-based test for {func.name}()"""')
+        
+        # Add precondition assumptions
+        if func.preconditions:
+            lines.append("        # Assume preconditions hold")
+            for pre in func.preconditions:
+                assumption = self._convert_precondition_to_assumption(pre)
+                if assumption:
+                    lines.append(f"        {assumption}")
+        
+        # Call the function
+        param_names = list(strategies.keys()) if strategies else []
+        if param_names:
+            lines.append(f"        result = {func.name}({', '.join(param_names)})")
+        else:
+            lines.append(f"        # result = {func.name}(...) # TODO: Provide appropriate arguments")
+            lines.append("        pass  # Remove this when implementing")
+            return lines
+        
+        # Assert postconditions
+        if func.postconditions:
+            lines.append("        # Assert postconditions")
+            for post in func.postconditions:
+                assertion = self._convert_postcondition_to_assertion(post, "result")
+                if assertion:
+                    lines.append(f"        {assertion}")
+        
+        return lines
+    
+    def _generate_precondition_tests(self, func: FunctionAnnotation) -> List[str]:
+        """Generate tests that verify preconditions are enforced."""
+        lines = []
+        
+        lines.append("    def test_precondition_enforcement(self):")
+        lines.append(f'        """Test that {func.name}() enforces its preconditions"""')
+        
+        for i, pre in enumerate(func.preconditions):
+            lines.append(f"        # Precondition {i+1}: {pre}")
+            
+            # Try to generate a violation test
+            violation = self._generate_precondition_violation(pre, func.name)
+            if violation:
+                lines.append(f"        # Test violation: {violation}")
+        
+        lines.append("        # TODO: Implement specific precondition violation tests")
+        lines.append("        pass")
+        
+        return lines
+    
+    def _generate_postcondition_tests(self, func: FunctionAnnotation) -> List[str]:
+        """Generate tests that verify postconditions hold."""
+        lines = []
+        
+        lines.append("    def test_postconditions_hold(self):")
+        lines.append(f'        """Test that postconditions hold after {func.name}() executes"""')
+        
+        for i, post in enumerate(func.postconditions):
+            lines.append(f"        # Postcondition {i+1}: {post}")
+            assertion = self._convert_postcondition_to_assertion(post, "result")
+            if assertion:
+                lines.append(f"        # {assertion}")
+        
+        lines.append("        # TODO: Call function with valid inputs and verify postconditions")
+        lines.append("        pass")
+        
+        return lines
+    
+    def _generate_invariant_tests(self, func: FunctionAnnotation) -> List[str]:
+        """Generate tests for function invariants."""
+        lines = []
+        
+        lines.append("    def test_invariants(self):")
+        lines.append(f'        """Test that invariants hold throughout {func.name}() execution"""')
+        
+        for i, inv in enumerate(func.invariants):
+            lines.append(f"        # Invariant {i+1}: {inv}")
+        
+        lines.append("        # TODO: Verify invariants before, during, and after execution")
+        lines.append("        pass")
+        
+        return lines
+    
+    def _generate_error_case_tests(self, func: FunctionAnnotation) -> List[str]:
+        """Generate tests for error cases."""
+        lines = []
+        
+        for i, error in enumerate(func.error_cases):
+            error_str = str(error)
+            
+            # Parse error case
+            if hasattr(error, 'condition') and hasattr(error, 'error_type'):
+                condition = error.condition
+                error_type = error.error_type
+            elif '→' in error_str:
+                parts = error_str.split('→')
+                condition = parts[0].strip()
+                error_type = parts[1].strip() if len(parts) > 1 else "Exception"
+            else:
+                condition = error_str
+                error_type = "Exception"
+            
+            test_name = f"test_error_case_{i+1}_{self._sanitize_name(condition)}"
+            lines.append(f"    def {test_name}(self):")
+            lines.append(f'        """Test error case: {condition}"""')
+            lines.append(f"        with pytest.raises({error_type}):")
+            lines.append(f"            # Create condition: {condition}")
+            lines.append(f"            {func.name}(...)  # TODO: Provide arguments that trigger {condition}")
+            lines.append("")
+        
+        return lines
+    
+    def _generate_edge_case_tests(self, func: FunctionAnnotation) -> List[str]:
+        """Generate edge case tests based on common patterns."""
+        lines = []
+        
+        lines.append("    def test_edge_cases(self):")
+        lines.append(f'        """Test edge cases for {func.name}()"""')
+        lines.append("        # Common edge cases to consider:")
+        lines.append("        # - Empty inputs (empty strings, empty lists, None)")
+        lines.append("        # - Boundary values (0, -1, max int, min int)")
+        lines.append("        # - Special values (NaN, Infinity for numbers)")
+        lines.append("        # TODO: Implement edge case tests based on function signature")
+        lines.append("        pass")
+        
+        return lines
+    
+    def _generate_performance_test(self, func: FunctionAnnotation) -> List[str]:
+        """Generate performance/complexity test."""
+        lines = []
+        
+        lines.append("    def test_performance(self):")
+        lines.append(f'        """Test performance characteristics of {func.name}()"""')
+        lines.append(f"        # Expected complexity: Time={func.complexity.time}, Space={func.complexity.space}")
+        lines.append("        import time")
+        lines.append("        ")
+        lines.append("        # TODO: Implement performance test")
+        lines.append("        # Measure execution time for various input sizes")
+        lines.append("        # Verify it matches the expected complexity")
+        lines.append("        pass")
+        
+        return lines
+    
+    def _generate_happy_path_test(self, func: FunctionAnnotation) -> List[str]:
+        """Generate happy path test."""
+        lines = []
+        
+        lines.append("    def test_happy_path(self):")
+        lines.append(f'        """Test normal execution of {func.name}()"""')
+        
+        if func.preconditions:
+            lines.append("        # Ensure all preconditions are met:")
+            for pre in func.preconditions:
+                lines.append(f"        #   - {pre}")
+        
+        lines.append(f"        # result = {func.name}(...)  # TODO: Provide valid arguments")
+        
+        if func.postconditions:
+            lines.append("        # Verify all postconditions hold:")
+            for post in func.postconditions:
+                lines.append(f"        #   - {post}")
+        
+        lines.append("        pass")
+        
+        return lines
+    
+    def _infer_strategies_from_preconditions(self, preconditions: List[str]) -> Dict[str, str]:
+        """Infer Hypothesis strategies from preconditions."""
+        strategies = {}
+        
+        for pre in preconditions:
+            # Pattern: "x > 0 and x < 100" or "0 < x < 100" → x: st.integers(min_value=1, max_value=99)
+            if match := re.match(r'(\w+)\s*>\s*(\d+)\s+and\s+\1\s*<\s*(\d+)', pre):
+                var_name = match.group(1)
+                min_val = int(match.group(2)) + 1
+                max_val = int(match.group(3)) - 1
+                strategies[var_name] = f"st.integers(min_value={min_val}, max_value={max_val})"
+            
+            # Pattern: "0 < x < 100" (mathematical notation)
+            elif match := re.match(r'(\d+)\s*<\s*(\w+)\s*<\s*(\d+)', pre):
+                var_name = match.group(2)
+                min_val = int(match.group(1)) + 1
+                max_val = int(match.group(3)) - 1
+                strategies[var_name] = f"st.integers(min_value={min_val}, max_value={max_val})"
+            
+            # Pattern: "x >= 0 and x <= 100"
+            elif match := re.match(r'(\w+)\s*>=\s*(\d+)\s+and\s+\1\s*<=\s*(\d+)', pre):
+                var_name = match.group(1)
+                min_val = int(match.group(2))
+                max_val = int(match.group(3))
+                strategies[var_name] = f"st.integers(min_value={min_val}, max_value={max_val})"
+            
+            # Pattern: "x in [1, 2, 3]" → x: st.sampled_from([1, 2, 3])
+            elif match := re.match(r'(\w+)\s+in\s+\[(.+?)\]', pre):
+                var_name = match.group(1)
+                values = match.group(2)
+                strategies[var_name] = f"st.sampled_from([{values}])"
+            
+            # Pattern: "x > 0" → x: st.integers(min_value=1)
+            elif match := re.match(r'(\w+)\s*>\s*(\d+)', pre):
+                var_name = match.group(1)
+                min_val = int(match.group(2)) + 1
+                if var_name not in strategies:  # Don't override compound conditions
+                    strategies[var_name] = f"st.integers(min_value={min_val})"
+            
+            # Pattern: "x >= 0" → x: st.integers(min_value=0)
+            elif match := re.match(r'(\w+)\s*>=\s*(\d+)', pre):
+                var_name = match.group(1)
+                min_val = int(match.group(2))
+                if var_name not in strategies:
+                    strategies[var_name] = f"st.integers(min_value={min_val})"
+            
+            # Pattern: "x < 100" → x: st.integers(max_value=99)
+            elif match := re.match(r'(\w+)\s*<\s*(\d+)', pre):
+                var_name = match.group(1)
+                max_val = int(match.group(2)) - 1
+                if var_name not in strategies:
+                    strategies[var_name] = f"st.integers(max_value={max_val})"
+            
+            # Pattern: "x <= 100" → x: st.integers(max_value=100)
+            elif match := re.match(r'(\w+)\s*<=\s*(\d+)', pre):
+                var_name = match.group(1)
+                max_val = int(match.group(2))
+                if var_name not in strategies:
+                    strategies[var_name] = f"st.integers(max_value={max_val})"
+            
+            # Pattern: "x is string" or "x must be string"
+            elif match := re.search(r'(\w+).*(?:is|must be).*string', pre, re.IGNORECASE):
+                var_name = match.group(1)
+                if var_name not in strategies:
+                    strategies[var_name] = "st.text()"
+            
+            # Pattern: "x is list" or "x must be list"
+            elif match := re.search(r'(\w+).*(?:is|must be).*list', pre, re.IGNORECASE):
+                var_name = match.group(1)
+                if var_name not in strategies:
+                    strategies[var_name] = "st.lists(st.integers())"
+            
+            # Pattern: "x is boolean" or "x must be boolean"
+            elif match := re.search(r'(\w+).*(?:is|must be).*(?:bool|boolean)', pre, re.IGNORECASE):
+                var_name = match.group(1)
+                if var_name not in strategies:
+                    strategies[var_name] = "st.booleans()"
+            
+            # Pattern: "x is float" or "x must be float"
+            elif match := re.search(r'(\w+).*(?:is|must be).*(?:float|decimal|number)', pre, re.IGNORECASE):
+                var_name = match.group(1)
+                if var_name not in strategies:
+                    strategies[var_name] = "st.floats(allow_nan=False, allow_infinity=False)"
+        
+        return strategies
+    
+    def _convert_precondition_to_assumption(self, precondition: str) -> Optional[str]:
+        """Convert a precondition to a Hypothesis assume() statement."""
+        # Pattern: "x > 0"
+        if match := re.match(r'(\w+)\s*>\s*(\d+)', precondition):
+            var_name = match.group(1)
+            value = match.group(2)
+            return f"assume({var_name} > {value})"
+        
+        # Pattern: "x >= 0"
+        elif match := re.match(r'(\w+)\s*>=\s*(\d+)', precondition):
+            var_name = match.group(1)
+            value = match.group(2)
+            return f"assume({var_name} >= {value})"
+        
+        # Pattern: "x is not None" or "x must not be None"
+        elif match := re.search(r'(\w+).*(?:is not|must not be).*None', precondition, re.IGNORECASE):
+            var_name = match.group(1)
+            return f"assume({var_name} is not None)"
+        
+        return None
+    
+    def _convert_postcondition_to_assertion(self, postcondition: str, result_var: str = "result") -> Optional[str]:
+        """Convert a postcondition to an assertion."""
+        # Pattern: "result > 0"
+        if match := re.match(r'result\s*>\s*(\d+)', postcondition):
+            value = match.group(1)
+            return f"assert {result_var} > {value}"
+        
+        # Pattern: "result >= 0"
+        elif match := re.match(r'result\s*>=\s*(\d+)', postcondition):
+            value = match.group(1)
+            return f"assert {result_var} >= {value}"
+        
+        # Pattern: "returns true" or "result is true"
+        elif re.search(r'(?:returns|result is)\s+true', postcondition, re.IGNORECASE):
+            return f"assert {result_var} is True"
+        
+        # Pattern: "returns false" or "result is false"
+        elif re.search(r'(?:returns|result is)\s+false', postcondition, re.IGNORECASE):
+            return f"assert {result_var} is False"
+        
+        # Pattern: "result is not None"
+        elif re.search(r'result.*is not None', postcondition, re.IGNORECASE):
+            return f"assert {result_var} is not None"
+        
+        # Pattern: "result ⇔ condition" (if and only if)
+        elif '⇔' in postcondition or 'if and only if' in postcondition:
+            # This is a complex logical condition, generate a comment
+            return f"# TODO: Verify: {postcondition}"
+        
+        return None
+    
+    def _generate_precondition_violation(self, precondition: str, func_name: str) -> Optional[str]:
+        """Generate code that violates a precondition."""
+        # Pattern: "x > 0" → call with x = 0 or x = -1
+        if match := re.match(r'(\w+)\s*>\s*(\d+)', precondition):
+            var_name = match.group(1)
+            value = match.group(2)
+            return f"{func_name}({var_name}={value})"
+        
+        # Pattern: "x must not be None" → call with x = None
+        elif match := re.search(r'(\w+).*must not be None', precondition, re.IGNORECASE):
+            var_name = match.group(1)
+            return f"{func_name}({var_name}=None)"
+        
+        return None
+    
+    def _sanitize_name(self, name: str) -> str:
+        """Sanitize a string to be a valid Python identifier."""
+        # Remove special characters and replace spaces with underscores
+        sanitized = re.sub(r'[^a-zA-Z0-9_]', '_', name)
+        sanitized = re.sub(r'_+', '_', sanitized)
+        return sanitized.strip('_').lower()[:50]  # Limit length
+    
+    def _generate_pytest_class_tests(self, cls: ClassAnnotation) -> List[str]:
+        """Generate pytest tests for a class."""
+        lines = []
+        
+        test_class_name = f"Test{cls.name}"
+        lines.append(f"class {test_class_name}:")
+        lines.append(f'    """Tests for {cls.name}"""')
+        lines.append("")
+        
+        # Fixture for class instance
+        lines.append("    @pytest.fixture")
+        lines.append("    def instance(self):")
+        lines.append(f'        """Create a {cls.name} instance for testing"""')
+        lines.append(f"        return {cls.name}()  # TODO: Provide appropriate constructor arguments")
+        lines.append("")
+        
+        # Test class invariants
+        if cls.class_invariants:
+            lines.append("    def test_class_invariants(self, instance):")
+            lines.append(f'        """Test that class invariants always hold"""')
+            for i, inv in enumerate(cls.class_invariants):
+                lines.append(f"        # Invariant {i+1}: {inv}")
+            lines.append("        # TODO: Verify invariants hold after construction")
+            lines.append("        pass")
+            lines.append("")
+        
+        # Test state transitions
+        if cls.state_transitions:
+            lines.append("    def test_state_transitions(self, instance):")
+            lines.append(f'        """Test valid state transitions"""')
+            for st in cls.state_transitions:
+                lines.append(f"        # Transition: {st}")
+            lines.append("        # TODO: Test each valid state transition")
+            lines.append("        pass")
+            lines.append("")
+        
+        # Test each method
+        for method in cls.methods:
+            lines.extend(self._generate_pytest_method_tests(cls, method))
+            lines.append("")
+        
+        return lines
+    
+    def _generate_pytest_method_tests(self, cls: ClassAnnotation, method: FunctionAnnotation) -> List[str]:
+        """Generate pytest tests for a class method."""
+        lines = []
+        
+        # Method test
+        test_name = f"test_{method.name}"
+        lines.append(f"    def {test_name}(self, instance):")
+        lines.append(f'        """Test {cls.name}.{method.name}()"""')
+        
+        if method.preconditions:
+            lines.append("        # Preconditions:")
+            for pre in method.preconditions:
+                lines.append(f"        #   - {pre}")
+        
+        lines.append(f"        # result = instance.{method.name}(...)  # TODO: Provide arguments")
+        
+        if method.postconditions:
+            lines.append("        # Postconditions:")
+            for post in method.postconditions:
+                lines.append(f"        #   - {post}")
+        
+        lines.append("        pass")
+        
+        return lines
+    
+    def _generate_unittest(self, parsed: ParsedAnnotations, output_file: Optional[str] = None) -> str:
+        """Generate unittest test cases."""
+        # Keep the existing unittest implementation
+        lines = []
+        
+        # Header
+        lines.append('"""')
+        lines.append(f"Automated tests for {parsed.module.name}")
+        lines.append("Generated from @voodocs annotations")
+        lines.append('"""')
+        lines.append("")
+        lines.append("import unittest")
+        lines.append(f"from {parsed.module.name} import *")
+        lines.append("")
+        lines.append("")
+        
+        # Generate test classes
+        all_functions = parsed.get_all_functions()
+        for func in all_functions:
+            test_class_name = f"Test{func.name.replace('_', ' ').title().replace(' ', '')}"
+            lines.append(f"class {test_class_name}(unittest.TestCase):")
+            lines.append(f'    """Tests for {func.name}()"""')
+            lines.append("")
+            lines.append("    def test_basic(self):")
+            lines.append("        # TODO: Implement test")
+            lines.append("        pass")
+            lines.append("")
+        
+        # Main
+        lines.append("")
+        lines.append('if __name__ == "__main__":')
+        lines.append("    unittest.main()")
+        
+        test_code = "\n".join(lines)
+        
+        if output_file:
+            output_path = Path(output_file)
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+            output_path.write_text(test_code, encoding='utf-8')
+        
+        return test_code
+    
+    def _generate_jest(self, parsed: ParsedAnnotations, output_file: Optional[str] = None) -> str:
+        """Generate Jest test cases for JavaScript/TypeScript."""
+        # Keep the existing Jest implementation
+        lines = []
+        
+        # Header
+        lines.append("/**")
+        lines.append(f" * Automated tests for {parsed.module.name}")
+        lines.append(" * Generated from @voodocs annotations")
+        lines.append(" */")
+        lines.append("")
+        lines.append(f"import * as module from './{parsed.module.name}';")
+        lines.append("")
+        
+        # Generate test suites
+        all_functions = parsed.get_all_functions()
+        for func in all_functions:
+            lines.append(f"describe('{func.name}', () => {{")
+            
+            if func.preconditions:
+                lines.append("  test('should enforce preconditions', () => {")
+                for pre in func.preconditions:
+                    lines.append(f"    // Precondition: {pre}")
+                lines.append("    // TODO: Implement test")
+                lines.append("  });")
+                lines.append("")
+            
+            if func.postconditions:
+                lines.append("  test('should satisfy postconditions', () => {")
+                for post in func.postconditions:
+                    lines.append(f"    // Postcondition: {post}")
+                lines.append("    // TODO: Implement test")
+                lines.append("  });")
+                lines.append("")
+            
+            lines.append("  test('should work in happy path', () => {")
+            lines.append("    // TODO: Implement test")
+            lines.append("  });")
+            lines.append("});")
+            lines.append("")
+        
+        test_code = "\n".join(lines)
+        
+        if output_file:
+            output_path = Path(output_file)
+            output_path.parent.mkdir(parents=True, exist_ok=True)
+            output_path.write_text(test_code, encoding='utf-8')
+        
+        return test_code