attune-ai 2.0.0__py3-none-any.whl

attune/test_generator/risk_analyzer.py

@@ -0,0 +1,216 @@
+"""Risk analyzer for test generation.
+
+Analyzes workflow 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 workflow."""
+
+    workflow_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 {
+            "workflow_id": self.workflow_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 workflow 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, workflow_id: str, pattern_ids: list[str]) -> RiskAnalysis:
+        """Analyze workflow patterns for risk.
+
+        Args:
+            workflow_id: Workflow identifier
+            pattern_ids: List of pattern IDs used by workflow
+
+        Returns:
+            RiskAnalysis with recommendations
+
+        """
+        logger.info(f"Analyzing risk for workflow: {workflow_id}")
+
+        analysis = RiskAnalysis(
+            workflow_id=workflow_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

attune/test_generator/templates/unit_test.py.jinja2

@@ -0,0 +1,272 @@
+"""Unit tests for {{ wizard_id }} wizard.
+
+Auto-generated by Empathy Framework Test Generator
+Risk Analysis: {{ risk_analysis.critical_paths|length }} critical paths identified
+Target Coverage: {{ risk_analysis.recommended_coverage }}%
+Generated: {{ timestamp }}
+"""
+
+import pytest
+{% if has_async %}
+import asyncio
+{% endif %}
+from unittest.mock import MagicMock, patch, AsyncMock
+
+from {{ wizard_module }} import {{ wizard_class }}
+
+
+class Test{{ wizard_class }}:
+    """Test {{ wizard_id }} wizard."""
+
+    @pytest.fixture
+    def wizard(self):
+        """Create wizard instance."""
+        return {{ wizard_class }}()
+
+    {% if 'approval' in pattern_ids %}
+    # =========================================================================
+    # CRITICAL: User Approval Tests (Priority 1)
+    # =========================================================================
+
+    {% if has_async %}async {% endif %}def test_cannot_save_without_preview(self, wizard):
+        """CRITICAL: Saving without preview should fail.
+
+        Risk: Users bypassing review step could save unreviewed content
+        Priority: 1 (Critical)
+        Pattern: approval
+        """
+        {% if has_async %}
+        with pytest.raises(Exception) as exc:
+            await wizard.save(wizard_id="test", approval={"user_approved": True})
+        {% else %}
+        with pytest.raises(Exception) as exc:
+            wizard.save(wizard_id="test", approval={"user_approved": True})
+        {% endif %}
+
+        # Should fail with preview requirement message
+        assert "preview" in str(exc.value).lower()
+
+    {% if has_async %}async {% endif %}def test_cannot_save_without_approval(self, wizard):
+        """CRITICAL: Saving without user approval should fail.
+
+        Risk: Content finalized without explicit user consent
+        Priority: 1 (Critical)
+        Pattern: approval
+        """
+        {% if has_async %}
+        # Generate preview first
+        await wizard.preview(wizard_id="test")
+
+        # Try to save without approval
+        with pytest.raises(Exception) as exc:
+            await wizard.save(wizard_id="test", approval={"user_approved": False})
+        {% else %}
+        wizard.preview(wizard_id="test")
+
+        with pytest.raises(Exception) as exc:
+            wizard.save(wizard_id="test", approval={"user_approved": False})
+        {% endif %}
+
+        # Should fail with approval requirement
+        assert "approval" in str(exc.value).lower()
+
+    {% if has_async %}async {% endif %}def test_preview_does_not_finalize(self, wizard):
+        """CRITICAL: Preview should NOT mark wizard as complete.
+
+        Risk: Users locked out from editing after preview
+        Priority: 1 (Critical)
+        Pattern: approval
+        """
+        {% if has_async %}
+        session = await wizard.start()
+        wizard_id = session["wizard_id"]
+
+        # Generate preview
+        preview = await wizard.preview(wizard_id)
+
+        # Check wizard NOT marked complete
+        session = await wizard.get_session(wizard_id)
+        {% else %}
+        session = wizard.start()
+        wizard_id = session["wizard_id"]
+
+        preview = wizard.preview(wizard_id)
+
+        session = wizard.get_session(wizard_id)
+        {% endif %}
+
+        assert session.get("completed", False) is False
+        assert "preview_report" in session  # Preview exists
+        assert "final_report" not in session  # But not finalized
+    {% endif %}
+
+    {% if 'step_validation' in pattern_ids %}
+    # =========================================================================
+    # CRITICAL: Step Validation Tests (Priority 1)
+    # =========================================================================
+
+    {% if has_async %}async {% endif %}def test_cannot_skip_steps(self, wizard):
+        """CRITICAL: Steps must be completed in order.
+
+        Risk: Users skipping required data collection steps
+        Priority: 1 (Critical)
+        Pattern: step_validation
+        """
+        {% if has_async %}
+        session = await wizard.start()
+        wizard_id = session["wizard_id"]
+
+        # Try to skip to step 3
+        with pytest.raises(Exception) as exc:
+            await wizard.submit_step(wizard_id, {"step": 3, "data": {}})
+        {% else %}
+        session = wizard.start()
+        wizard_id = session["wizard_id"]
+
+        with pytest.raises(Exception) as exc:
+            wizard.submit_step(wizard_id, {"step": 3, "data": {}})
+        {% endif %}
+
+        assert "expected step 1" in str(exc.value).lower() or "step" in str(exc.value).lower()
+
+    {% if has_async %}async {% endif %}def test_step_sequence_enforced(self, wizard):
+        """CRITICAL: Wrong step number should be rejected.
+
+        Risk: Step sequence corruption
+        Priority: 1 (Critical)
+        Pattern: step_validation
+        """
+        {% if has_async %}
+        session = await wizard.start()
+        wizard_id = session["wizard_id"]
+
+        # Submit wrong step number
+        with pytest.raises(Exception) as exc:
+            await wizard.submit_step(wizard_id, {"step": 99, "data": {}})
+        {% else %}
+        session = wizard.start()
+        wizard_id = session["wizard_id"]
+
+        with pytest.raises(Exception) as exc:
+            wizard.submit_step(wizard_id, {"step": 99, "data": {}})
+        {% endif %}
+
+        assert exc.value is not None
+    {% endif %}
+
+    {% if 'risk_assessment' in pattern_ids %}
+    # =========================================================================
+    # Risk Assessment Tests (Priority 2)
+    # =========================================================================
+
+    def test_risk_assessment_identifies_critical_issues(self, wizard):
+        """Risk assessment should flag critical issues.
+
+        Priority: 2 (High)
+        Pattern: risk_assessment
+        """
+        issues = [
+            {"severity": "critical", "message": "Test issue"}
+        ]
+
+        risk_result = wizard.assess_risk(issues)
+
+        assert risk_result["alert_level"] == "CRITICAL"
+        assert risk_result["by_risk_level"]["critical"] == 1
+    {% endif %}
+
+    {% if 'phased_processing' in pattern_ids %}
+    # =========================================================================
+    # Phased Processing Tests (Priority 1)
+    # =========================================================================
+
+    {% for phase in phases %}
+    {% if has_async %}async {% endif %}def test_phase_{{ phase.name }}(self, wizard):
+        """Test {{ phase.name }} phase execution.
+
+        Priority: 1 (Critical path)
+        Pattern: phased_processing
+        """
+        context = {"test": "data"}
+
+        {% if has_async %}
+        result = await wizard._{{ phase.name }}(context)
+        {% else %}
+        result = wizard._{{ phase.name }}(context)
+        {% endif %}
+
+        assert result is not None
+        assert isinstance(result, dict)
+    {% endfor %}
+    {% endif %}
+
+    # =========================================================================
+    # Success Path Tests (Priority 4)
+    # =========================================================================
+
+    {% if has_async %}async {% endif %}def test_happy_path_success(self, wizard):
+        """Test complete wizard flow succeeds.
+
+        Priority: 4 (Success path)
+        """
+        {% if 'linear_flow' in pattern_ids %}
+        # Start wizard
+        {% if has_async %}
+        session = await wizard.start()
+        {% else %}
+        session = wizard.start()
+        {% endif %}
+        wizard_id = session["wizard_id"]
+
+        assert wizard_id is not None
+        assert session["current_step"] == 1
+
+        # Complete all steps
+        for step in range(1, {{ total_steps or 5 }}):
+            {% if has_async %}
+            result = await wizard.submit_step(
+                wizard_id,
+                {"step": step, "data": {"test": f"data_{step}"}}
+            )
+            {% else %}
+            result = wizard.submit_step(
+                wizard_id,
+                {"step": step, "data": {"test": f"data_{step}"}}
+            )
+            {% endif %}
+            assert result is not None
+
+        # Generate preview
+        {% if has_async %}
+        preview = await wizard.preview(wizard_id)
+        {% else %}
+        preview = wizard.preview(wizard_id)
+        {% endif %}
+        assert preview is not None
+
+        # Save with approval
+        {% if has_async %}
+        final = await wizard.save(wizard_id, {"user_approved": True})
+        {% else %}
+        final = wizard.save(wizard_id, {"user_approved": True})
+        {% endif %}
+        assert final["completed"] is True
+        {% else %}
+        # Test basic wizard functionality
+        result = wizard.process({"test": "data"})
+        assert result is not None
+        {% endif %}
+
+    # =========================================================================
+    # Validation Tests (Priority 3)
+    # =========================================================================
+
+    {% for validation in risk_analysis.validation_points[:5] %}
+    def test_{{ validation }}_validated(self, wizard):
+        """Test {{ validation }} is properly validated.
+
+        Priority: 3 (Validation point)
+        """
+        # TODO: Implement validation test for {{ validation }}
+        pass
+    {% endfor %}