attune-ai 2.0.0__py3-none-any.whl

attune/workflows/test_gen/report_formatter.py

@@ -0,0 +1,289 @@
+"""Test Generation Report Formatter.
+
+Format test generation output as human-readable reports.
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+import re
+
+
+def format_test_gen_report(result: dict, input_data: dict) -> str:
+    """Format test generation output as a human-readable report.
+
+    Args:
+        result: The review stage result
+        input_data: Input data from previous stages
+
+    Returns:
+        Formatted report string
+
+    """
+    lines = []
+
+    # Header
+    total_tests = result.get("total_tests", 0)
+    files_covered = result.get("files_covered", 0)
+
+    lines.append("=" * 60)
+    lines.append("TEST GAP ANALYSIS REPORT")
+    lines.append("=" * 60)
+    lines.append("")
+
+    # Summary stats
+    total_candidates = input_data.get("total_candidates", 0)
+    hotspot_count = input_data.get("hotspot_count", 0)
+    untested_count = input_data.get("untested_count", 0)
+
+    lines.append("-" * 60)
+    lines.append("SUMMARY")
+    lines.append("-" * 60)
+    lines.append(f"Tests Generated:     {total_tests}")
+    lines.append(f"Files Covered:       {files_covered}")
+    lines.append(f"Total Candidates:    {total_candidates}")
+    lines.append(f"Bug Hotspots Found:  {hotspot_count}")
+    lines.append(f"Untested Files:      {untested_count}")
+    lines.append("")
+
+    # Status indicator
+    if total_tests == 0:
+        lines.append("⚠️  No tests were generated")
+    elif total_tests < 5:
+        lines.append(f"🟡 Generated {total_tests} test(s) - consider adding more coverage")
+    elif total_tests < 20:
+        lines.append(f"🟢 Generated {total_tests} tests - good coverage")
+    else:
+        lines.append(f"✅ Generated {total_tests} tests - excellent coverage")
+    lines.append("")
+
+    # Scope notice for enterprise clarity
+    total_source = input_data.get("total_source_files", 0)
+    existing_tests = input_data.get("existing_test_files", 0)
+    coverage_pct = input_data.get("analysis_coverage_percent", 100)
+    large_project = input_data.get("large_project_warning", False)
+
+    if total_source > 0 or existing_tests > 0:
+        lines.append("-" * 60)
+        lines.append("SCOPE NOTICE")
+        lines.append("-" * 60)
+
+        if large_project:
+            lines.append("⚠️  LARGE PROJECT: Only high-priority files analyzed")
+            lines.append(f"   Coverage: {coverage_pct:.0f}% of candidate files")
+            lines.append("")
+
+        lines.append(f"Source Files Found:   {total_source}")
+        lines.append(f"Existing Test Files:  {existing_tests}")
+        lines.append(f"Files Analyzed:       {files_covered}")
+
+        if existing_tests > 0:
+            lines.append("")
+            lines.append("Note: This report identifies gaps in untested files.")
+            lines.append("Run 'pytest --co -q' for full test suite statistics.")
+        lines.append("")
+
+    # Parse XML review feedback if present
+    review = result.get("review_feedback", "")
+    xml_summary = ""
+    xml_findings = []
+    xml_tests = []
+    coverage_improvement = ""
+
+    if review and "<response>" in review:
+        # Extract summary
+        summary_match = re.search(r"<summary>(.*?)</summary>", review, re.DOTALL)
+        if summary_match:
+            xml_summary = summary_match.group(1).strip()
+
+        # Extract coverage improvement
+        coverage_match = re.search(
+            r"<coverage-improvement>(.*?)</coverage-improvement>",
+            review,
+            re.DOTALL,
+        )
+        if coverage_match:
+            coverage_improvement = coverage_match.group(1).strip()
+
+        # Extract findings
+        for finding_match in re.finditer(
+            r'<finding severity="(\w+)">(.*?)</finding>',
+            review,
+            re.DOTALL,
+        ):
+            severity = finding_match.group(1)
+            finding_content = finding_match.group(2)
+
+            title_match = re.search(r"<title>(.*?)</title>", finding_content, re.DOTALL)
+            location_match = re.search(r"<location>(.*?)</location>", finding_content, re.DOTALL)
+            fix_match = re.search(r"<fix>(.*?)</fix>", finding_content, re.DOTALL)
+
+            xml_findings.append(
+                {
+                    "severity": severity,
+                    "title": title_match.group(1).strip() if title_match else "Unknown",
+                    "location": location_match.group(1).strip() if location_match else "",
+                    "fix": fix_match.group(1).strip() if fix_match else "",
+                },
+            )
+
+        # Extract suggested tests
+        for test_match in re.finditer(r'<test target="([^"]+)">(.*?)</test>', review, re.DOTALL):
+            target = test_match.group(1)
+            test_content = test_match.group(2)
+
+            type_match = re.search(r"<type>(.*?)</type>", test_content, re.DOTALL)
+            desc_match = re.search(r"<description>(.*?)</description>", test_content, re.DOTALL)
+
+            xml_tests.append(
+                {
+                    "target": target,
+                    "type": type_match.group(1).strip() if type_match else "unit",
+                    "description": desc_match.group(1).strip() if desc_match else "",
+                },
+            )
+
+    # Show parsed summary
+    if xml_summary:
+        lines.append("-" * 60)
+        lines.append("QUALITY ASSESSMENT")
+        lines.append("-" * 60)
+        # Word wrap the summary
+        words = xml_summary.split()
+        current_line = ""
+        for word in words:
+            if len(current_line) + len(word) + 1 <= 58:
+                current_line += (" " if current_line else "") + word
+            else:
+                lines.append(current_line)
+                current_line = word
+        if current_line:
+            lines.append(current_line)
+        lines.append("")
+
+        if coverage_improvement:
+            lines.append(f"📈 {coverage_improvement}")
+            lines.append("")
+
+    # Show findings by severity
+    if xml_findings:
+        lines.append("-" * 60)
+        lines.append("QUALITY FINDINGS")
+        lines.append("-" * 60)
+
+        severity_emoji = {"high": "🔴", "medium": "🟠", "low": "🟡", "info": "🔵"}
+        severity_order = {"high": 0, "medium": 1, "low": 2, "info": 3}
+
+        sorted_findings = sorted(xml_findings, key=lambda f: severity_order.get(f["severity"], 4))
+
+        for finding in sorted_findings:
+            emoji = severity_emoji.get(finding["severity"], "⚪")
+            lines.append(f"{emoji} [{finding['severity'].upper()}] {finding['title']}")
+            if finding["location"]:
+                lines.append(f"   Location: {finding['location']}")
+            if finding["fix"]:
+                # Truncate long fix recommendations
+                fix_text = finding["fix"]
+                if len(fix_text) > 70:
+                    fix_text = fix_text[:67] + "..."
+                lines.append(f"   Fix: {fix_text}")
+            lines.append("")
+
+    # Show suggested tests
+    if xml_tests:
+        lines.append("-" * 60)
+        lines.append("SUGGESTED TESTS TO ADD")
+        lines.append("-" * 60)
+
+        for i, test in enumerate(xml_tests[:5], 1):  # Limit to 5
+            lines.append(f"{i}. {test['target']} ({test['type']})")
+            if test["description"]:
+                desc = test["description"]
+                if len(desc) > 55:
+                    desc = desc[:52] + "..."
+                lines.append(f"   {desc}")
+            lines.append("")
+
+        if len(xml_tests) > 5:
+            lines.append(f"   ... and {len(xml_tests) - 5} more suggested tests")
+            lines.append("")
+
+    # Generated tests breakdown (if no XML data)
+    generated_tests = input_data.get("generated_tests", [])
+    if generated_tests and not xml_findings:
+        lines.append("-" * 60)
+        lines.append("GENERATED TESTS BY FILE")
+        lines.append("-" * 60)
+        for test_file in generated_tests[:10]:  # Limit display
+            source = test_file.get("source_file", "unknown")
+            test_count = test_file.get("test_count", 0)
+            # Shorten path for display
+            if len(source) > 50:
+                source = "..." + source[-47:]
+            lines.append(f"  📁 {source}")
+            lines.append(
+                f"     └─ {test_count} test(s) → {test_file.get('test_file', 'test_*.py')}",
+            )
+        if len(generated_tests) > 10:
+            lines.append(f"  ... and {len(generated_tests) - 10} more files")
+        lines.append("")
+
+    # Written files section
+    written_files = input_data.get("written_files", [])
+    if written_files:
+        lines.append("-" * 60)
+        lines.append("TESTS WRITTEN TO DISK")
+        lines.append("-" * 60)
+        for file_path in written_files[:10]:
+            # Shorten path for display
+            if len(file_path) > 55:
+                file_path = "..." + file_path[-52:]
+            lines.append(f"  ✅ {file_path}")
+        if len(written_files) > 10:
+            lines.append(f"  ... and {len(written_files) - 10} more files")
+        lines.append("")
+        lines.append("  Run: pytest <file> to execute these tests")
+        lines.append("")
+    elif input_data.get("tests_written") is False and total_tests > 0:
+        lines.append("-" * 60)
+        lines.append("GENERATED TESTS (NOT WRITTEN)")
+        lines.append("-" * 60)
+        lines.append("  ⚠️  Tests were generated but not written to disk.")
+        lines.append("  To write tests, run with: write_tests=True")
+        lines.append("")
+
+    # Recommendations
+    lines.append("-" * 60)
+    lines.append("NEXT STEPS")
+    lines.append("-" * 60)
+
+    high_findings = sum(1 for f in xml_findings if f["severity"] == "high")
+    medium_findings = sum(1 for f in xml_findings if f["severity"] == "medium")
+
+    if high_findings > 0:
+        lines.append(f"  🔴 Address {high_findings} high-priority finding(s) first")
+
+    if medium_findings > 0:
+        lines.append(f"  🟠 Review {medium_findings} medium-priority finding(s)")
+
+    if xml_tests:
+        lines.append(f"  📝 Consider adding {len(xml_tests)} suggested test(s)")
+
+    if hotspot_count > 0:
+        lines.append(f"  🔥 {hotspot_count} bug hotspot file(s) need priority testing")
+
+    if untested_count > 0:
+        lines.append(f"  📁 {untested_count} file(s) have no existing tests")
+
+    if not any([high_findings, medium_findings, xml_tests, hotspot_count, untested_count]):
+        lines.append("  ✅ Test suite is in good shape!")
+
+    lines.append("")
+
+    # Footer
+    lines.append("=" * 60)
+    model_tier = result.get("model_tier_used", "unknown")
+    lines.append(f"Review completed using {model_tier} tier model")
+    lines.append("=" * 60)
+
+    return "\n".join(lines)

attune/workflows/test_gen/test_templates.py

@@ -0,0 +1,381 @@
+"""Test Template Generation.
+
+Functions to generate pytest test code for functions and classes.
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+
+
+def generate_test_for_function(module: str, func: dict) -> str:
+    """Generate executable tests for a function based on AST analysis."""
+    name = func["name"]
+    params = func.get("params") or []  # List of (name, type, default) tuples, handle None
+    param_names = func.get("param_names") or [p[0] if isinstance(p, tuple) else p for p in params]
+    is_async = func.get("is_async", False)
+    return_type = func.get("return_type")
+    raises = func.get("raises") or []
+    has_side_effects = func.get("has_side_effects", False)
+
+    # Generate test values based on parameter types
+    test_cases = generate_test_cases_for_params(params)
+    param_str = ", ".join(test_cases.get("valid_args", [""] * len(params)))
+
+    # Build parametrized test if we have multiple test cases
+    parametrize_cases = test_cases.get("parametrize_cases", [])
+
+    tests = []
+    tests.append(f"import pytest\nfrom {module} import {name}\n")
+
+    # Generate parametrized test if we have cases
+    if parametrize_cases and len(parametrize_cases) > 1:
+        param_names_str = ", ".join(param_names) if param_names else "value"
+        cases_str = ",\n    ".join(parametrize_cases)
+
+        if is_async:
+            tests.append(
+                f'''
+@pytest.mark.parametrize("{param_names_str}", [
+    {cases_str},
+])
+@pytest.mark.asyncio
+async def test_{name}_with_various_inputs({param_names_str}):
+    """Test {name} with various input combinations."""
+    result = await {name}({", ".join(param_names)})
+    assert result is not None
+''',
+            )
+        else:
+            tests.append(
+                f'''
+@pytest.mark.parametrize("{param_names_str}", [
+    {cases_str},
+])
+def test_{name}_with_various_inputs({param_names_str}):
+    """Test {name} with various input combinations."""
+    result = {name}({", ".join(param_names)})
+    assert result is not None
+''',
+            )
+    # Simple valid input test
+    elif is_async:
+        tests.append(
+            f'''
+@pytest.mark.asyncio
+async def test_{name}_returns_value():
+    """Test that {name} returns a value with valid inputs."""
+    result = await {name}({param_str})
+    assert result is not None
+''',
+        )
+    else:
+        tests.append(
+            f'''
+def test_{name}_returns_value():
+    """Test that {name} returns a value with valid inputs."""
+    result = {name}({param_str})
+    assert result is not None
+''',
+        )
+
+    # Generate edge case tests based on parameter types
+    edge_cases = test_cases.get("edge_cases", [])
+    if edge_cases:
+        edge_cases_str = ",\n    ".join(edge_cases)
+        if is_async:
+            tests.append(
+                f'''
+@pytest.mark.parametrize("edge_input", [
+    {edge_cases_str},
+])
+@pytest.mark.asyncio
+async def test_{name}_edge_cases(edge_input):
+    """Test {name} with edge case inputs."""
+    try:
+        result = await {name}(edge_input)
+        # Function should either return a value or raise an expected error
+        assert result is not None or result == 0 or result == "" or result == []
+    except (ValueError, TypeError, KeyError) as e:
+        # Expected error for edge cases
+        assert str(e)  # Error message should not be empty
+''',
+            )
+        else:
+            tests.append(
+                f'''
+@pytest.mark.parametrize("edge_input", [
+    {edge_cases_str},
+])
+def test_{name}_edge_cases(edge_input):
+    """Test {name} with edge case inputs."""
+    try:
+        result = {name}(edge_input)
+        # Function should either return a value or raise an expected error
+        assert result is not None or result == 0 or result == "" or result == []
+    except (ValueError, TypeError, KeyError) as e:
+        # Expected error for edge cases
+        assert str(e)  # Error message should not be empty
+''',
+            )
+
+    # Generate exception tests for each raised exception
+    for exc_type in raises[:3]:  # Limit to 3 exception types
+        if is_async:
+            tests.append(
+                f'''
+@pytest.mark.asyncio
+async def test_{name}_raises_{exc_type.lower()}():
+    """Test that {name} raises {exc_type} for invalid inputs."""
+    with pytest.raises({exc_type}):
+        await {name}(None)  # Adjust input to trigger {exc_type}
+''',
+            )
+        else:
+            tests.append(
+                f'''
+def test_{name}_raises_{exc_type.lower()}():
+    """Test that {name} raises {exc_type} for invalid inputs."""
+    with pytest.raises({exc_type}):
+        {name}(None)  # Adjust input to trigger {exc_type}
+''',
+            )
+
+    # Add return type assertion if we know the type
+    if return_type and return_type not in ("None", "Any"):
+        type_check = get_type_assertion(return_type)
+        if type_check and not has_side_effects:
+            if is_async:
+                tests.append(
+                    f'''
+@pytest.mark.asyncio
+async def test_{name}_returns_correct_type():
+    """Test that {name} returns the expected type."""
+    result = await {name}({param_str})
+    {type_check}
+''',
+                )
+            else:
+                tests.append(
+                    f'''
+def test_{name}_returns_correct_type():
+    """Test that {name} returns the expected type."""
+    result = {name}({param_str})
+    {type_check}
+''',
+                )
+
+    return "\n".join(tests)
+
+
+def generate_test_cases_for_params(params: list) -> dict:
+    """Generate test cases based on parameter types."""
+    valid_args = []
+    parametrize_cases = []
+    edge_cases = []
+
+    for param in params:
+        if isinstance(param, tuple) and len(param) >= 2:
+            _name, type_hint, default = param[0], param[1], param[2] if len(param) > 2 else None
+        else:
+            _name = param if isinstance(param, str) else str(param)
+            type_hint = "Any"
+            default = None
+
+        # Generate valid value based on type
+        if "str" in type_hint.lower():
+            valid_args.append('"test_value"')
+            parametrize_cases.extend(['"hello"', '"world"', '"test_string"'])
+            edge_cases.extend(['""', '" "', '"a" * 1000'])
+        elif "int" in type_hint.lower():
+            valid_args.append("42")
+            parametrize_cases.extend(["0", "1", "100", "-1"])
+            edge_cases.extend(["0", "-1", "2**31 - 1"])
+        elif "float" in type_hint.lower():
+            valid_args.append("3.14")
+            parametrize_cases.extend(["0.0", "1.0", "-1.5", "100.5"])
+            edge_cases.extend(["0.0", "-0.0", "float('inf')"])
+        elif "bool" in type_hint.lower():
+            valid_args.append("True")
+            parametrize_cases.extend(["True", "False"])
+        elif "list" in type_hint.lower():
+            valid_args.append("[1, 2, 3]")
+            parametrize_cases.extend(["[]", "[1]", "[1, 2, 3]"])
+            edge_cases.extend(["[]", "[None]"])
+        elif "dict" in type_hint.lower():
+            valid_args.append('{"key": "value"}')
+            parametrize_cases.extend(["{}", '{"a": 1}', '{"key": "value"}'])
+            edge_cases.extend(["{}"])
+        elif default is not None:
+            valid_args.append(str(default))
+        else:
+            valid_args.append("None")
+            edge_cases.append("None")
+
+    return {
+        "valid_args": valid_args,
+        "parametrize_cases": parametrize_cases[:5],  # Limit cases
+        "edge_cases": list(dict.fromkeys(edge_cases))[
+            :5
+        ],  # Unique edge cases (preserves order)
+    }
+
+
+def get_type_assertion(return_type: str) -> str | None:
+    """Generate assertion for return type checking."""
+    type_map = {
+        "str": "assert isinstance(result, str)",
+        "int": "assert isinstance(result, int)",
+        "float": "assert isinstance(result, (int, float))",
+        "bool": "assert isinstance(result, bool)",
+        "list": "assert isinstance(result, list)",
+        "dict": "assert isinstance(result, dict)",
+        "tuple": "assert isinstance(result, tuple)",
+    }
+    for type_name, assertion in type_map.items():
+        if type_name in return_type.lower():
+            return assertion
+    return None
+
+
+def get_param_test_values(type_hint: str) -> list[str]:
+    """Get test values for a single parameter based on its type."""
+    type_hint_lower = type_hint.lower()
+    if "str" in type_hint_lower:
+        return ['"hello"', '"world"', '"test_string"']
+    if "int" in type_hint_lower:
+        return ["0", "1", "42", "-1"]
+    if "float" in type_hint_lower:
+        return ["0.0", "1.0", "3.14"]
+    if "bool" in type_hint_lower:
+        return ["True", "False"]
+    if "list" in type_hint_lower:
+        return ["[]", "[1, 2, 3]"]
+    if "dict" in type_hint_lower:
+        return ["{}", '{"key": "value"}']
+    return ['"test_value"']
+
+
+def generate_test_for_class(module: str, cls: dict) -> str:
+    """Generate executable test class based on AST analysis."""
+    name = cls["name"]
+    init_params = cls.get("init_params", [])
+    methods = cls.get("methods", [])
+    required_params = cls.get("required_init_params", 0)
+    _docstring = cls.get("docstring", "")  # Reserved for future use
+
+    # Generate constructor arguments - ensure we have values for ALL required params
+    init_args = generate_test_cases_for_params(init_params)
+    valid_args = init_args.get("valid_args", [])
+
+    # Ensure we have enough args for required params
+    while len(valid_args) < required_params:
+        valid_args.append('"test_value"')
+
+    init_arg_str = ", ".join(valid_args)
+
+    tests = []
+    tests.append(f"import pytest\nfrom {module} import {name}\n")
+
+    # Fixture for class instance
+    tests.append(
+        f'''
+@pytest.fixture
+def {name.lower()}_instance():
+    """Create a {name} instance for testing."""
+    return {name}({init_arg_str})
+''',
+    )
+
+    # Test initialization
+    tests.append(
+        f'''
+class Test{name}:
+    """Tests for {name} class."""
+
+    def test_initialization(self):
+        """Test that {name} can be instantiated."""
+        instance = {name}({init_arg_str})
+        assert instance is not None
+''',
+    )
+
+    # Only generate parametrized tests for single-param classes to avoid tuple mismatches
+    if len(init_params) == 1 and init_params[0][2] is None:
+        # Single required param - safe to parametrize
+        param_name = init_params[0][0]
+        param_type = init_params[0][1]
+        cases = get_param_test_values(param_type)
+        if len(cases) > 1:
+            cases_str = ",\n        ".join(cases)
+            tests.append(
+                f'''
+    @pytest.mark.parametrize("{param_name}", [
+        {cases_str},
+    ])
+    def test_initialization_with_various_args(self, {param_name}):
+        """Test {name} initialization with various arguments."""
+        instance = {name}({param_name})
+        assert instance is not None
+''',
+            )
+
+    # Generate tests for each public method
+    for method in methods[:5]:  # Limit to 5 methods
+        method_name = method.get("name", "")
+        if method_name.startswith("_") and method_name != "__init__":
+            continue
+        if method_name == "__init__":
+            continue
+
+        method_params = method.get("params", [])[1:]  # Skip self
+        is_async = method.get("is_async", False)
+        raises = method.get("raises", [])
+
+        # Generate method call args
+        method_args = generate_test_cases_for_params(method_params)
+        method_arg_str = ", ".join(method_args.get("valid_args", []))
+
+        if is_async:
+            tests.append(
+                f'''
+    @pytest.mark.asyncio
+    async def test_{method_name}_returns_value(self, {name.lower()}_instance):
+        """Test that {method_name} returns a value."""
+        result = await {name.lower()}_instance.{method_name}({method_arg_str})
+        assert result is not None or result == 0 or result == "" or result == []
+''',
+            )
+        else:
+            tests.append(
+                f'''
+    def test_{method_name}_returns_value(self, {name.lower()}_instance):
+        """Test that {method_name} returns a value."""
+        result = {name.lower()}_instance.{method_name}({method_arg_str})
+        assert result is not None or result == 0 or result == "" or result == []
+''',
+            )
+
+        # Add exception tests for methods that raise
+        for exc_type in raises[:2]:
+            if is_async:
+                tests.append(
+                    f'''
+    @pytest.mark.asyncio
+    async def test_{method_name}_raises_{exc_type.lower()}(self, {name.lower()}_instance):
+        """Test that {method_name} raises {exc_type} for invalid inputs."""
+        with pytest.raises({exc_type}):
+            await {name.lower()}_instance.{method_name}(None)
+''',
+                )
+            else:
+                tests.append(
+                    f'''
+    def test_{method_name}_raises_{exc_type.lower()}(self, {name.lower()}_instance):
+        """Test that {method_name} raises {exc_type} for invalid inputs."""
+        with pytest.raises({exc_type}):
+            {name.lower()}_instance.{method_name}(None)
+''',
+                )
+
+    return "\n".join(tests)