attune-ai 2.0.0__py3-none-any.whl

attune/test_generator/__init__.py

@@ -0,0 +1,38 @@
+"""Risk-Driven Test Generator for Workflow Factory.
+
+Generates comprehensive tests for workflows based on risk analysis and patterns.
+
+Features:
+- Risk-based test prioritization
+- Pattern-driven test generation
+- Jinja2 templates for unit/integration/E2E tests
+- Fixture generation for common patterns
+- CLI integration
+
+Usage:
+    from test_generator import TestGenerator
+
+    generator = TestGenerator()
+    tests = generator.generate_tests(
+        workflow_id="soap_note",
+        pattern_ids=["linear_flow", "approval", "structured_fields"]
+    )
+
+    # Write tests to file
+    with open("test_soap_note.py", "w") as f:
+        f.write(tests["unit"])
+
+Copyright 2025 Smart AI Memory, LLC
+Licensed under Fair Source 0.9
+"""
+
+from .generator import TestGenerator
+from .risk_analyzer import RiskAnalysis, RiskAnalyzer
+
+__all__ = [
+    "TestGenerator",
+    "RiskAnalyzer",
+    "RiskAnalysis",
+]
+
+__version__ = "1.0.0"

attune/test_generator/__main__.py

@@ -0,0 +1,14 @@
+"""Make test_generator runnable as a module.
+
+Usage:
+    python -m test_generator generate soap_note --patterns linear_flow,approval
+    python -m test_generator analyze debugging --patterns code_analysis_input
+
+Copyright 2025 Smart AI Memory, LLC
+Licensed under Fair Source 0.9
+"""
+
+from .cli import main
+
+if __name__ == "__main__":
+    main()

attune/test_generator/cli.py

@@ -0,0 +1,234 @@
+"""CLI for test generator.
+
+Usage:
+    python -m test_generator.cli generate soap_note --patterns linear_flow,approval,structured_fields
+    python -m test_generator.cli analyze soap_note --patterns linear_flow,approval
+
+Copyright 2025 Smart AI Memory, LLC
+Licensed under Fair Source 0.9
+"""
+
+import argparse
+import heapq
+import json
+import logging
+import sys
+from pathlib import Path
+
+from attune.config import _validate_file_path
+
+from .generator import TestGenerator
+from .risk_analyzer import RiskAnalyzer
+
+logging.basicConfig(
+    level=logging.INFO,
+    format="%(levelname)s: %(message)s",
+)
+logger = logging.getLogger(__name__)
+
+
+def cmd_generate(args):
+    """Generate tests for a workflow.
+
+    Args:
+        args: Command line arguments
+
+    """
+    workflow_id = args.workflow_id
+    pattern_ids = args.patterns.split(",") if args.patterns else []
+
+    logger.info(f"Generating tests for workflow: {workflow_id}")
+    logger.info(f"Patterns: {', '.join(pattern_ids)}")
+
+    # Generate tests
+    generator = TestGenerator()
+    tests = generator.generate_tests(
+        workflow_id=workflow_id,
+        pattern_ids=pattern_ids,
+        workflow_module=args.module,
+        workflow_class=args.workflow_class,
+    )
+
+    # Determine output directory
+    output_dir = Path(args.output) if args.output else Path("tests/unit/workflows")
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    # Write unit tests
+    unit_test_file = output_dir / f"test_{workflow_id}_workflow.py"
+    validated_unit_test = _validate_file_path(str(unit_test_file))
+    with open(validated_unit_test, "w") as f:
+        f.write(tests["unit"])
+    logger.info(f"✓ Unit tests written to: {validated_unit_test}")
+
+    # Write integration tests (if generated)
+    if tests["integration"]:
+        integration_test_file = (
+            output_dir.parent.parent / "integration" / f"test_{workflow_id}_integration.py"
+        )
+        integration_test_file.parent.mkdir(parents=True, exist_ok=True)
+        validated_integration = _validate_file_path(str(integration_test_file))
+        with open(validated_integration, "w") as f:
+            f.write(tests["integration"])
+        logger.info(f"✓ Integration tests written to: {validated_integration}")
+
+    # Write fixtures
+    fixtures_file = output_dir / f"fixtures_{workflow_id}.py"
+    validated_fixtures = _validate_file_path(str(fixtures_file))
+    with open(validated_fixtures, "w") as f:
+        f.write(tests["fixtures"])
+    logger.info(f"✓ Fixtures written to: {validated_fixtures}")
+
+    print("\n🎉 Test generation complete!")
+    print("\nGenerated files:")
+    print(f"  - {unit_test_file}")
+    if tests["integration"]:
+        print(f"  - {integration_test_file}")
+    print(f"  - {fixtures_file}")
+
+    print("\nNext steps:")
+    print("  1. Review generated tests")
+    print(f"  2. Run tests: pytest {unit_test_file}")
+    print("  3. Add custom test cases as needed")
+
+
+def cmd_analyze(args):
+    """Analyze workflow risk and show recommendations.
+
+    Args:
+        args: Command line arguments
+
+    """
+    workflow_id = args.workflow_id
+    pattern_ids = args.patterns.split(",") if args.patterns else []
+
+    logger.info(f"Analyzing workflow: {workflow_id}")
+
+    # Perform risk analysis
+    analyzer = RiskAnalyzer()
+    analysis = analyzer.analyze(workflow_id, pattern_ids)
+
+    # Display results
+    print(f"\n{'=' * 60}")
+    print(f"Risk Analysis: {workflow_id}")
+    print(f"{'=' * 60}\n")
+
+    print(f"Patterns Used: {len(analysis.pattern_ids)}")
+    for pid in analysis.pattern_ids:
+        print(f"  - {pid}")
+
+    print(f"\nCritical Paths: {len(analysis.critical_paths)}")
+    for path in analysis.critical_paths:
+        print(f"  - {path}")
+
+    print(f"\nHigh-Risk Inputs: {len(analysis.high_risk_inputs)}")
+    for input_risk in analysis.high_risk_inputs[:5]:  # Top 5
+        print(f"  - {input_risk}")
+
+    print(f"\nValidation Points: {len(analysis.validation_points)}")
+    for validation in analysis.validation_points[:5]:  # Top 5
+        print(f"  - {validation}")
+
+    print(f"\n{'=' * 60}")
+    print(f"Recommended Test Coverage: {analysis.recommended_coverage}%")
+    print(f"{'=' * 60}\n")
+
+    print("Test Priorities:")
+    for test_name, priority in heapq.nsmallest(
+        10, analysis.test_priorities.items(), key=lambda x: x[1]
+    ):
+        priority_label = {
+            1: "CRITICAL",
+            2: "HIGH",
+            3: "MEDIUM",
+            4: "LOW",
+            5: "OPTIONAL",
+        }.get(priority, "UNKNOWN")
+        print(f"  [{priority_label:8}] {test_name}")
+
+    # JSON output if requested
+    if args.json:
+        json_output = analysis.to_dict()
+        json_file = Path(f"{workflow_id}_risk_analysis.json")
+        with open(json_file, "w") as f:
+            json.dump(json_output, f, indent=2)
+        print(f"\n✓ JSON output written to: {json_file}")
+
+
+def main():
+    """Main CLI entry point."""
+    parser = argparse.ArgumentParser(
+        description="Test Generator for Empathy Workflow Factory",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  # Generate tests for SOAP Note workflow
+  %(prog)s generate soap_note --patterns linear_flow,approval,structured_fields
+
+  # Analyze risk for debugging workflow
+  %(prog)s analyze debugging --patterns code_analysis_input,risk_assessment
+
+  # Generate with custom module/class
+  %(prog)s generate my_workflow --patterns linear_flow --module workflows.my_workflow --class MyWorkflow
+
+  # Output to custom directory
+  %(prog)s generate soap_note --patterns linear_flow --output tests/custom/
+        """,
+    )
+
+    subparsers = parser.add_subparsers(dest="command", help="Command to run")
+
+    # Generate command
+    gen_parser = subparsers.add_parser("generate", help="Generate tests for a workflow")
+    gen_parser.add_argument("workflow_id", help="Workflow identifier (e.g., soap_note)")
+    gen_parser.add_argument(
+        "--patterns",
+        required=True,
+        help="Comma-separated pattern IDs (e.g., linear_flow,approval)",
+    )
+    gen_parser.add_argument(
+        "--module",
+        help="Python module path (e.g., workflows.soap_note)",
+    )
+    gen_parser.add_argument(
+        "--class",
+        dest="workflow_class",
+        help="Workflow class name (e.g., SOAPNoteWorkflow)",
+    )
+    gen_parser.add_argument(
+        "--output",
+        "-o",
+        help="Output directory (default: tests/unit/workflows/)",
+    )
+
+    # Analyze command
+    analyze_parser = subparsers.add_parser("analyze", help="Analyze workflow risk")
+    analyze_parser.add_argument("workflow_id", help="Workflow identifier")
+    analyze_parser.add_argument(
+        "--patterns",
+        required=True,
+        help="Comma-separated pattern IDs",
+    )
+    analyze_parser.add_argument(
+        "--json",
+        action="store_true",
+        help="Output JSON file with analysis results",
+    )
+
+    args = parser.parse_args()
+
+    if not args.command:
+        parser.print_help()
+        sys.exit(1)
+
+    # Execute command
+    if args.command == "generate":
+        cmd_generate(args)
+    elif args.command == "analyze":
+        cmd_analyze(args)
+    else:
+        parser.print_help()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

attune/test_generator/generator.py

@@ -0,0 +1,355 @@
+"""Test generator core implementation.
+
+Generates comprehensive tests for workflows using Jinja2 templates
+and risk-based prioritization.
+
+Copyright 2025 Smart AI Memory, LLC
+Licensed under Fair Source 0.9
+"""
+
+import logging
+from datetime import datetime
+from pathlib import Path
+from typing import Any
+
+from jinja2 import Environment, FileSystemLoader
+
+from patterns import get_pattern_registry
+from patterns.structural import LinearFlowPattern, PhasedProcessingPattern
+
+from .risk_analyzer import RiskAnalyzer
+
+logger = logging.getLogger(__name__)
+
+
+def _get_default_template_dir() -> Path:
+    """Get default template directory.
+
+    Returns:
+        Path to templates directory
+
+    Note:
+        Uses multiple fallback strategies to avoid __file__ AttributeError
+        in pytest environments.
+    """
+    try:
+        # Try __file__ first (works in most cases)
+        return Path(__file__).parent / "templates"
+    except (AttributeError, NameError):
+        # Fallback: Use module __spec__ if available
+        import importlib.util
+        import sys
+
+        spec = importlib.util.find_spec("attune.test_generator")
+        if spec and spec.origin:
+            return Path(spec.origin).parent / "templates"
+
+        # Last resort: Try to find from sys.modules
+        this_module = sys.modules.get(__name__)
+        if this_module and hasattr(this_module, "__file__") and this_module.__file__:
+            return Path(this_module.__file__).parent / "templates"
+
+        # Final fallback: Use current working directory
+        return Path.cwd() / "src" / "attune" / "test_generator" / "templates"
+
+
+class TestGenerator:
+    """Generates tests for workflows based on patterns and risk analysis.
+
+    Uses Jinja2 templates to generate:
+    - Unit tests with risk-prioritized coverage
+    - Integration tests for multi-step workflows
+    - E2E tests for critical paths
+    - Test fixtures for common patterns
+    """
+
+    def __init__(self, template_dir: Path | None = None):
+        """Initialize test generator.
+
+        Args:
+            template_dir: Directory containing Jinja2 templates
+                         (defaults to test_generator/templates/)
+
+        """
+        if template_dir is None:
+            template_dir = _get_default_template_dir()
+
+        self.template_dir = template_dir
+        self.env = Environment(
+            loader=FileSystemLoader(str(template_dir)),
+            trim_blocks=True,
+            lstrip_blocks=True,
+            autoescape=True,  # Enable autoescape for security (test gen templates should be safe)
+        )
+
+        self.risk_analyzer = RiskAnalyzer()
+        self.registry = get_pattern_registry()
+
+    def generate_tests(
+        self,
+        workflow_id: str,
+        pattern_ids: list[str],
+        workflow_module: str | None = None,
+        workflow_class: str | None = None,
+    ) -> dict[str, str | None]:
+        """Generate tests for a workflow.
+
+        Args:
+            workflow_id: Workflow identifier
+            pattern_ids: List of pattern IDs used by workflow
+            workflow_module: Python module path (e.g., "workflows.soap_note")
+            workflow_class: Workflow class name (e.g., "SOAPNoteWorkflow")
+
+        Returns:
+            Dictionary with test types:
+                {
+                    "unit": "...",  # Unit test code
+                    "integration": "...",  # Integration test code (if applicable)
+                    "fixtures": "...",  # Test fixtures
+                }
+
+        """
+        logger.info(f"Generating tests for workflow: {workflow_id}")
+
+        # Perform risk analysis
+        risk_analysis = self.risk_analyzer.analyze(workflow_id, pattern_ids)
+
+        # Infer module and class if not provided
+        if not workflow_module:
+            workflow_module = self._infer_module(workflow_id)
+
+        if not workflow_class:
+            workflow_class = self._infer_class_name(workflow_id)
+
+        # Gather template context
+        context = self._build_template_context(
+            workflow_id=workflow_id,
+            pattern_ids=pattern_ids,
+            workflow_module=workflow_module,
+            workflow_class=workflow_class,
+            risk_analysis=risk_analysis,
+        )
+
+        # Generate unit tests (always)
+        unit_tests = self._generate_unit_tests(context)
+
+        # Generate integration tests (for multi-step workflows)
+        integration_tests = None
+        if self._needs_integration_tests(pattern_ids):
+            integration_tests = self._generate_integration_tests(context)
+
+        # Generate test fixtures
+        fixtures = self._generate_fixtures(context)
+
+        logger.info(
+            f"Generated tests for {workflow_id}: "
+            f"unit={len(unit_tests)} chars, "
+            f"integration={'yes' if integration_tests else 'no'}, "
+            f"fixtures={len(fixtures)} chars"
+        )
+
+        return {
+            "unit": unit_tests,
+            "integration": integration_tests,
+            "fixtures": fixtures,
+        }
+
+    def _build_template_context(
+        self,
+        workflow_id: str,
+        pattern_ids: list[str],
+        workflow_module: str,
+        workflow_class: str,
+        risk_analysis: Any,
+    ) -> dict:
+        """Build Jinja2 template context.
+
+        Args:
+            workflow_id: Workflow identifier
+            pattern_ids: Pattern IDs
+            workflow_module: Module path
+            workflow_class: Class name
+            risk_analysis: RiskAnalysis object
+
+        Returns:
+            Context dictionary for templates
+
+        """
+        # Get pattern details
+        patterns = [self.registry.get(pid) for pid in pattern_ids if self.registry.get(pid)]
+
+        # Check for specific patterns
+        has_linear_flow = "linear_flow" in pattern_ids
+        has_phased = "phased_processing" in pattern_ids
+        has_approval = "approval" in pattern_ids
+        has_async = True  # Assume async by default for modern workflows
+
+        # Get linear flow details if present
+        total_steps = None
+        if has_linear_flow:
+            linear_pattern = self.registry.get("linear_flow")
+            if isinstance(linear_pattern, LinearFlowPattern):
+                total_steps = linear_pattern.total_steps
+
+        # Get phases if present
+        phases = []
+        if has_phased:
+            phased_pattern = self.registry.get("phased_processing")
+            if isinstance(phased_pattern, PhasedProcessingPattern):
+                phases = phased_pattern.phases
+
+        return {
+            "workflow_id": workflow_id,
+            "workflow_module": workflow_module,
+            "workflow_class": workflow_class,
+            "pattern_ids": pattern_ids,
+            "patterns": patterns,
+            "risk_analysis": risk_analysis,
+            "has_async": has_async,
+            "has_linear_flow": has_linear_flow,
+            "has_phased": has_phased,
+            "has_approval": has_approval,
+            "total_steps": total_steps,
+            "phases": phases,
+            "timestamp": datetime.now().isoformat(),
+        }
+
+    def _generate_unit_tests(self, context: dict) -> str:
+        """Generate unit tests from template.
+
+        Args:
+            context: Template context
+
+        Returns:
+            Generated unit test code
+
+        """
+        template = self.env.get_template("unit_test.py.jinja2")
+        return template.render(**context)
+
+    def _generate_integration_tests(self, context: dict) -> str:
+        """Generate integration tests.
+
+        Args:
+            context: Template context
+
+        Returns:
+            Generated integration test code
+
+        """
+        # For now, return a simple integration test template
+        # In full implementation, would use integration_test.py.jinja2
+        return f'''"""Integration tests for {context["workflow_id"]} workflow.
+
+Auto-generated by Empathy Framework Test Generator
+Tests end-to-end workflow workflows.
+"""
+
+import pytest
+from {context["workflow_module"]} import {context["workflow_class"]}
+
+
+class TestIntegration{context["workflow_class"]}:
+    """Integration tests for {context["workflow_id"]} workflow."""
+
+    @pytest.fixture
+    async def workflow(self):
+        """Create workflow instance."""
+        return {context["workflow_class"]}()
+
+    @pytest.mark.asyncio
+    async def test_complete_workflow_workflow(self, workflow):
+        """Test complete workflow workflow end-to-end."""
+        # Start workflow
+        session = await workflow.start()
+        workflow_id = session["workflow_id"]
+
+        # Complete all steps with valid data
+        # TODO: Add step completion logic
+
+        # Verify final state
+        assert session.get("completed", False) is True
+'''
+
+    def _generate_fixtures(self, context: dict) -> str:
+        """Generate test fixtures.
+
+        Args:
+            context: Template context
+
+        Returns:
+            Generated fixture code
+
+        """
+        return f'''"""Test fixtures for {context["workflow_id"]} workflow.
+
+Auto-generated by Empathy Framework Test Generator
+Provides common test data and mocks.
+"""
+
+import pytest
+from unittest.mock import MagicMock
+
+
+@pytest.fixture
+def sample_{context["workflow_id"]}_data():
+    """Sample data for {context["workflow_id"]} workflow."""
+    return {{
+        "field1": "test value 1",
+        "field2": "test value 2",
+    }}
+
+
+@pytest.fixture
+def mock_{context["workflow_id"]}_dependencies():
+    """Mock dependencies for {context["workflow_id"]} workflow."""
+    return {{
+        "database": MagicMock(),
+        "api_client": MagicMock(),
+    }}
+'''
+
+    def _needs_integration_tests(self, pattern_ids: list[str]) -> bool:
+        """Determine if integration tests are needed.
+
+        Args:
+            pattern_ids: Pattern IDs
+
+        Returns:
+            True if integration tests recommended
+
+        """
+        # Integration tests for multi-step or phased workflows
+        return "linear_flow" in pattern_ids or "phased_processing" in pattern_ids
+
+    def _infer_module(self, workflow_id: str) -> str:
+        """Infer module path from workflow ID.
+
+        Args:
+            workflow_id: Workflow identifier
+
+        Returns:
+            Inferred module path
+
+        """
+        # Try to determine workflow location
+        # This is a simple heuristic - can be improved
+        if workflow_id in ["soap_note", "sbar", "care_plan"]:
+            return f"workflows.{workflow_id}"
+        else:
+            return f"workflows.{workflow_id}_workflow"
+
+    def _infer_class_name(self, workflow_id: str) -> str:
+        """Infer workflow class name from ID.
+
+        Args:
+            workflow_id: Workflow identifier
+
+        Returns:
+            Inferred class name
+
+        """
+        # Convert snake_case to PascalCase and add "Workflow"
+        parts = workflow_id.split("_")
+        class_name = "".join(part.capitalize() for part in parts)
+        return f"{class_name}Workflow"