tests/test_decision_engine.py

import pytest
import sys
import os

# Add parent directory to path
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

from logic.decision_engine import DecisionEngine
from schemas.motor_claim import MotorClaim
from schemas.medical_claim import MedicalClaim

def test_make_severity_decision_approval():
    """Test low-severity claim gets approved"""
    engine = DecisionEngine()
    
    claim = MotorClaim(
        claim_id="TEST-001",
        claim_type="motor",
        claim_amount=5000.0,
        coverage_limit=50000.0,
        prior_claims=0,
        previous_fraud_flag=False
    )
    
    result = engine.make_severity_decision(claim)
    
    assert result["decision"] == "APPROVED"
    assert result["confidence"] > 0.9
    assert result["request_id"] is not None
    assert result["timestamp"] is not None
    assert "explanation" in result
    assert isinstance(result["matched_rules"], list)

def test_make_severity_decision_rejection():
    """Test high-severity claim gets rejected"""
    engine = DecisionEngine()
    
    claim = MotorClaim(
        claim_id="TEST-002",
        claim_type="motor",
        claim_amount=60000.0,  # Exceeds coverage
        coverage_limit=50000.0,
        prior_claims=5,
        previous_fraud_flag=True
    )
    
    result = engine.make_severity_decision(claim)
    
    assert result["decision"] == "REJECTED"
    assert result["request_id"] is not None
    assert result["fraud_risk"] == True

def test_decision_persistence():
    """Test decisions are persisted to database"""
    from governance.decision_storage import DecisionStorage
    engine = DecisionEngine()
    
    claim = MotorClaim(
        claim_id="TEST-003",
        claim_type="motor",
        claim_amount=5000.0,
        coverage_limit=50000.0,
        prior_claims=0,
        previous_fraud_flag=False
    )
    
    result = engine.make_severity_decision(claim)
    request_id = result["request_id"]
    
    # Retrieve from database
    storage = DecisionStorage()
    retrieved = storage.get_decision_by_request_id(request_id)
    
    assert retrieved is not None
    assert retrieved["request_id"] == request_id
    assert retrieved["claim_id"] == "TEST-003"
    assert retrieved["severity"] == "APPROVED"

def test_medical_claim_approval():
    """Test medical claim processing"""
    engine = DecisionEngine()
    
    claim = MedicalClaim(
        claim_id="TEST-MED-001",
        claim_type="medical",
        claim_amount=3000.0,
        coverage_limit=100000.0,
        prior_claims=0,
        previous_fraud_flag=False,
        diagnosis_code="Z00.00",
        treatment_type="consultation"
    )
    
    result = engine.make_severity_decision(claim)
    
    assert result["decision"] == "APPROVED"
    assert result["confidence"] > 0.8
    assert result["request_id"] is not None

def test_llm_fallback():
    """Test that system works without LLM API key"""
    # Temporarily remove API key
    original_key = os.environ.get("OPENAI_API_KEY")
    if "OPENAI_API_KEY" in os.environ:
        del os.environ["OPENAI_API_KEY"]
    
    try:
        engine = DecisionEngine()
        
        claim = MotorClaim(
            claim_id="TEST-004",
            claim_type="motor",
            claim_amount=5000.0,
            coverage_limit=50000.0,
            prior_claims=0,
            previous_fraud_flag=False
        )
        
        result = engine.make_severity_decision(claim)
        
        # Should still work with fallback
        assert result["decision"] == "APPROVED"
        assert result["llm_used"] == False
        assert "explanation" in result
    finally:
        # Restore API key
        if original_key:
            os.environ["OPENAI_API_KEY"] = original_key

def test_structured_output():
    """Test that decision output has all required fields"""
    engine = DecisionEngine()
    
    claim = MotorClaim(
        claim_id="TEST-005",
        claim_type="motor",
        claim_amount=5000.0,
        coverage_limit=50000.0,
        prior_claims=0,
        previous_fraud_flag=False
    )
    
    result = engine.make_severity_decision(claim)
    
    # Check all required fields
    required_fields = [
        "decision", "confidence", "severity_score", "fraud_risk",
        "fraud_signals", "explanation", "coverage_valid", "request_id",
        "timestamp", "llm_used", "matched_rules"
    ]
    
    for field in required_fields:
        assert field in result, f"Missing required field: {field}"
    
    # Check data types
    assert isinstance(result["decision"], str)
    assert isinstance(result["confidence"], (int, float))
    assert isinstance(result["fraud_risk"], bool)
    assert isinstance(result["matched_rules"], list)
    assert isinstance(result["llm_used"], bool)