empathy-framework 5.3.0__py3-none-any.whl → 5.4.0__py3-none-any.whl

empathy_os/workflows/test_gen/report_formatter.py

@@ -1,289 +0,0 @@
-"""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)

empathy_os/workflows/test_gen/test_templates.py

@@ -1,381 +0,0 @@
-"""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)