empathy-framework 3.7.0__py3-none-any.whl → 3.8.0__py3-none-any.whl

test_generator/generator.py

@@ -0,0 +1,325 @@
+"""Test generator core implementation.
+
+Generates comprehensive tests for wizards 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__)
+
+
+class TestGenerator:
+    """Generates tests for wizards 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 = Path(__file__).parent / "templates"
+
+        self.template_dir = template_dir
+        self.env = Environment(
+            loader=FileSystemLoader(str(template_dir)),
+            trim_blocks=True,
+            lstrip_blocks=True,
+        )
+
+        self.risk_analyzer = RiskAnalyzer()
+        self.registry = get_pattern_registry()
+
+    def generate_tests(
+        self,
+        wizard_id: str,
+        pattern_ids: list[str],
+        wizard_module: str | None = None,
+        wizard_class: str | None = None,
+    ) -> dict[str, str]:
+        """Generate tests for a wizard.
+
+        Args:
+            wizard_id: Wizard identifier
+            pattern_ids: List of pattern IDs used by wizard
+            wizard_module: Python module path (e.g., "wizards.soap_note")
+            wizard_class: Wizard class name (e.g., "SOAPNoteWizard")
+
+        Returns:
+            Dictionary with test types:
+                {
+                    "unit": "...",  # Unit test code
+                    "integration": "...",  # Integration test code (if applicable)
+                    "fixtures": "...",  # Test fixtures
+                }
+
+        """
+        logger.info(f"Generating tests for wizard: {wizard_id}")
+
+        # Perform risk analysis
+        risk_analysis = self.risk_analyzer.analyze(wizard_id, pattern_ids)
+
+        # Infer module and class if not provided
+        if not wizard_module:
+            wizard_module = self._infer_module(wizard_id)
+
+        if not wizard_class:
+            wizard_class = self._infer_class_name(wizard_id)
+
+        # Gather template context
+        context = self._build_template_context(
+            wizard_id=wizard_id,
+            pattern_ids=pattern_ids,
+            wizard_module=wizard_module,
+            wizard_class=wizard_class,
+            risk_analysis=risk_analysis,
+        )
+
+        # Generate unit tests (always)
+        unit_tests = self._generate_unit_tests(context)
+
+        # Generate integration tests (for multi-step wizards)
+        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 {wizard_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,
+        wizard_id: str,
+        pattern_ids: list[str],
+        wizard_module: str,
+        wizard_class: str,
+        risk_analysis: Any,
+    ) -> dict:
+        """Build Jinja2 template context.
+
+        Args:
+            wizard_id: Wizard identifier
+            pattern_ids: Pattern IDs
+            wizard_module: Module path
+            wizard_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 wizards
+
+        # 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 {
+            "wizard_id": wizard_id,
+            "wizard_module": wizard_module,
+            "wizard_class": wizard_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["wizard_id"]} wizard.
+
+Auto-generated by Empathy Framework Test Generator
+Tests end-to-end wizard workflows.
+"""
+
+import pytest
+from {context["wizard_module"]} import {context["wizard_class"]}
+
+
+class TestIntegration{context["wizard_class"]}:
+    """Integration tests for {context["wizard_id"]} wizard."""
+
+    @pytest.fixture
+    async def wizard(self):
+        """Create wizard instance."""
+        return {context["wizard_class"]}()
+
+    @pytest.mark.asyncio
+    async def test_complete_wizard_workflow(self, wizard):
+        """Test complete wizard workflow end-to-end."""
+        # Start wizard
+        session = await wizard.start()
+        wizard_id = session["wizard_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["wizard_id"]} wizard.
+
+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["wizard_id"]}_data():
+    """Sample data for {context["wizard_id"]} wizard."""
+    return {{
+        "field1": "test value 1",
+        "field2": "test value 2",
+    }}
+
+
+@pytest.fixture
+def mock_{context["wizard_id"]}_dependencies():
+    """Mock dependencies for {context["wizard_id"]} wizard."""
+    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 wizards
+        return "linear_flow" in pattern_ids or "phased_processing" in pattern_ids
+
+    def _infer_module(self, wizard_id: str) -> str:
+        """Infer module path from wizard ID.
+
+        Args:
+            wizard_id: Wizard identifier
+
+        Returns:
+            Inferred module path
+
+        """
+        # Try to determine wizard location
+        # This is a simple heuristic - can be improved
+        if wizard_id in ["soap_note", "sbar", "care_plan"]:
+            return f"wizards.{wizard_id}"
+        elif wizard_id in ["debugging", "testing", "security"]:
+            return f"coach_wizards.{wizard_id}_wizard"
+        else:
+            return f"wizards.{wizard_id}_wizard"
+
+    def _infer_class_name(self, wizard_id: str) -> str:
+        """Infer wizard class name from ID.
+
+        Args:
+            wizard_id: Wizard identifier
+
+        Returns:
+            Inferred class name
+
+        """
+        # Convert snake_case to PascalCase and add "Wizard"
+        parts = wizard_id.split("_")
+        class_name = "".join(part.capitalize() for part in parts)
+        return f"{class_name}Wizard"

test_generator/risk_analyzer.py

@@ -0,0 +1,216 @@
+"""Risk analyzer for test generation.
+
+Analyzes wizard patterns to identify critical paths and determine
+appropriate test coverage levels.
+
+Copyright 2025 Smart AI Memory, LLC
+Licensed under Fair Source 0.9
+"""
+
+import logging
+from dataclasses import dataclass, field
+
+from patterns import get_pattern_registry
+from patterns.behavior import PredictionPattern, RiskAssessmentPattern
+from patterns.structural import PhasedProcessingPattern
+from patterns.validation import ApprovalPattern, StepValidationPattern
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class RiskAnalysis:
+    """Risk analysis results for a wizard."""
+
+    wizard_id: str
+    pattern_ids: list[str]
+    critical_paths: list[str] = field(default_factory=list)
+    high_risk_inputs: list[str] = field(default_factory=list)
+    validation_points: list[str] = field(default_factory=list)
+    recommended_coverage: int = 80  # Percentage
+    test_priorities: dict[str, int] = field(default_factory=dict)  # test_name -> priority (1-5)
+
+    def get_critical_test_cases(self) -> list[str]:
+        """Get list of critical test case names.
+
+        Returns:
+            List of critical test cases to implement
+
+        """
+        test_cases = []
+
+        # Critical paths become test cases
+        for path in self.critical_paths:
+            test_case = f"test_{path.lower().replace(' ', '_').replace('-', '_')}"
+            test_cases.append(test_case)
+
+        # High-risk inputs become test cases
+        for input_risk in self.high_risk_inputs:
+            test_case = f"test_{input_risk.lower().replace(' ', '_')}_validation"
+            test_cases.append(test_case)
+
+        return test_cases
+
+    def to_dict(self) -> dict:
+        """Convert to dictionary."""
+        return {
+            "wizard_id": self.wizard_id,
+            "pattern_ids": self.pattern_ids,
+            "critical_paths": self.critical_paths,
+            "high_risk_inputs": self.high_risk_inputs,
+            "validation_points": self.validation_points,
+            "recommended_coverage": self.recommended_coverage,
+            "test_priorities": self.test_priorities,
+        }
+
+
+class RiskAnalyzer:
+    """Analyzes wizard patterns to determine testing requirements.
+
+    Uses pattern analysis to identify:
+    - Critical execution paths
+    - High-risk input scenarios
+    - Required validation points
+    - Recommended test coverage level
+    """
+
+    def __init__(self):
+        """Initialize risk analyzer."""
+        self.registry = get_pattern_registry()
+
+    def analyze(self, wizard_id: str, pattern_ids: list[str]) -> RiskAnalysis:
+        """Analyze wizard patterns for risk.
+
+        Args:
+            wizard_id: Wizard identifier
+            pattern_ids: List of pattern IDs used by wizard
+
+        Returns:
+            RiskAnalysis with recommendations
+
+        """
+        logger.info(f"Analyzing risk for wizard: {wizard_id}")
+
+        analysis = RiskAnalysis(
+            wizard_id=wizard_id,
+            pattern_ids=pattern_ids,
+        )
+
+        # Analyze each pattern
+        for pattern_id in pattern_ids:
+            pattern = self.registry.get(pattern_id)
+            if not pattern:
+                logger.warning(f"Pattern not found: {pattern_id}")
+                continue
+
+            self._analyze_pattern(pattern, analysis)
+
+        # Calculate recommended coverage based on risk
+        self._calculate_coverage(analysis)
+
+        # Prioritize tests
+        self._prioritize_tests(analysis)
+
+        logger.info(
+            f"Risk analysis complete: {len(analysis.critical_paths)} critical paths, "
+            f"{analysis.recommended_coverage}% coverage recommended"
+        )
+
+        return analysis
+
+    def _analyze_pattern(self, pattern, analysis: RiskAnalysis) -> None:
+        """Analyze a specific pattern for risks.
+
+        Args:
+            pattern: Pattern to analyze
+            analysis: RiskAnalysis to update
+
+        """
+        # Approval patterns are CRITICAL - must test preview → approval flow
+        if isinstance(pattern, ApprovalPattern):
+            analysis.critical_paths.append("approval_workflow")
+            analysis.high_risk_inputs.append("save_without_preview")
+            analysis.high_risk_inputs.append("save_without_approval")
+            analysis.validation_points.append("preview_generated")
+            analysis.validation_points.append("user_approved")
+
+        # Step validation patterns - test step sequencing
+        elif isinstance(pattern, StepValidationPattern):
+            analysis.critical_paths.append("step_sequence_validation")
+            analysis.high_risk_inputs.append("skip_step")
+            analysis.high_risk_inputs.append("wrong_step_number")
+            analysis.validation_points.append("current_step")
+
+        # Phased processing - each phase is a critical path
+        elif isinstance(pattern, PhasedProcessingPattern):
+            for phase in pattern.phases:
+                analysis.critical_paths.append(f"phase_{phase.name}")
+                if phase.required:
+                    analysis.validation_points.append(f"{phase.name}_completed")
+
+        # Risk assessment patterns - test risk detection
+        elif isinstance(pattern, RiskAssessmentPattern):
+            analysis.critical_paths.append("risk_assessment")
+            analysis.validation_points.append("alert_level")
+            for level in pattern.risk_levels:
+                analysis.high_risk_inputs.append(f"{level.name}_threshold")
+
+        # Prediction patterns - test predictions
+        elif isinstance(pattern, PredictionPattern):
+            analysis.critical_paths.append("prediction_generation")
+            for pred_type in pattern.prediction_types:
+                analysis.validation_points.append(pred_type)
+
+    def _calculate_coverage(self, analysis: RiskAnalysis) -> None:
+        """Calculate recommended test coverage.
+
+        Args:
+            analysis: RiskAnalysis to update
+
+        """
+        # Base coverage
+        base_coverage = 70
+
+        # Add 5% for each critical path
+        critical_bonus = min(20, len(analysis.critical_paths) * 5)
+
+        # Add 3% for each validation point
+        validation_bonus = min(10, len(analysis.validation_points) * 3)
+
+        # Cap at 95%
+        analysis.recommended_coverage = min(
+            95,
+            base_coverage + critical_bonus + validation_bonus,
+        )
+
+    def _prioritize_tests(self, analysis: RiskAnalysis) -> None:
+        """Assign priorities to test cases.
+
+        Args:
+            analysis: RiskAnalysis to update
+
+        """
+        # Priority levels: 1 (critical) to 5 (nice-to-have)
+
+        # Critical paths = Priority 1
+        for path in analysis.critical_paths:
+            test_name = f"test_{path}"
+            analysis.test_priorities[test_name] = 1
+
+        # High-risk inputs = Priority 2
+        for input_risk in analysis.high_risk_inputs:
+            test_name = f"test_{input_risk}_validation"
+            analysis.test_priorities[test_name] = 2
+
+        # Validation points = Priority 3
+        for validation in analysis.validation_points:
+            test_name = f"test_{validation}"
+            if test_name not in analysis.test_priorities:
+                analysis.test_priorities[test_name] = 3
+
+        # Success path = Priority 4
+        analysis.test_priorities["test_success_path"] = 4
+        analysis.test_priorities["test_happy_path"] = 4
+
+        # Edge cases = Priority 5
+        analysis.test_priorities["test_edge_cases"] = 5

workflow_patterns/__init__.py

@@ -0,0 +1,33 @@
+"""Workflow Pattern Library.
+
+Extracted patterns from 17 existing workflows for rapid workflow generation.
+
+Copyright 2025 Smart-AI-Memory
+Licensed under Fair Source License 0.9
+"""
+
+from .behavior import CodeScannerPattern, ConditionalTierPattern, ConfigDrivenPattern
+from .core import PatternCategory, WorkflowComplexity, WorkflowPattern
+from .output import ResultDataclassPattern
+from .registry import WorkflowPatternRegistry, get_workflow_pattern_registry
+from .structural import CrewBasedPattern, MultiStagePattern, SingleStagePattern
+
+__all__ = [
+    # Core
+    "WorkflowPattern",
+    "PatternCategory",
+    "WorkflowComplexity",
+    # Structural
+    "SingleStagePattern",
+    "MultiStagePattern",
+    "CrewBasedPattern",
+    # Behavioral
+    "ConditionalTierPattern",
+    "ConfigDrivenPattern",
+    "CodeScannerPattern",
+    # Output
+    "ResultDataclassPattern",
+    # Registry
+    "WorkflowPatternRegistry",
+    "get_workflow_pattern_registry",
+]