tests/unit/test_consent_message_generator.py

#!/usr/bin/env python3
"""
Test script for the consent message generator.
Tests Task 5.2 implementation.
"""

import sys
import os
sys.path.append(os.path.join(os.path.dirname(__file__), '..', '..', 'src'))

from config.prompt_management.consent_message_generator import ConsentMessageGenerator
from config.prompt_management.consent_manager import ConsentMessageType
from config.prompt_management.data_models import Template


def test_consent_message_generator_initialization():
    """Test that the consent message generator initializes correctly."""
    print("Testing consent message generator initialization...")
    
    generator = ConsentMessageGenerator()
    
    # Verify components are initialized
    assert hasattr(generator, 'consent_manager')
    assert hasattr(generator, 'consent_templates')
    assert hasattr(generator, 'validation_rules')
    
    # Verify validation rules structure
    assert 'required_elements' in generator.validation_rules
    assert 'forbidden_elements' in generator.validation_rules
    
    # Verify required elements for each message type
    required_elements = generator.validation_rules['required_elements']
    assert 'initial_request' in required_elements
    assert 'clarification' in required_elements
    assert 'confirmation' in required_elements
    assert 'decline_acknowledgment' in required_elements
    
    print("✓ Consent message generator initializes correctly")
    return True


def test_consent_request_generation():
    """Test consent request generation with validation."""
    print("Testing consent request generation...")
    
    generator = ConsentMessageGenerator()
    
    # Test basic consent request generation
    result = generator.generate_consent_request()
    
    # Verify result structure
    required_fields = ['message', 'is_compliant', 'violations', 'validation_score', 
                      'message_type', 'generated_at', 'context_used']
    for field in required_fields:
        assert field in result, f"Result missing required field: {field}"
    
    # Verify message properties
    assert len(result['message']) > 0, "Generated message should not be empty"
    assert result['message_type'] == 'initial_request', "Should be initial request type"
    assert isinstance(result['is_compliant'], bool), "Compliance should be boolean"
    assert isinstance(result['violations'], list), "Violations should be list"
    assert 0.0 <= result['validation_score'] <= 1.0, "Validation score should be between 0 and 1"
    
    # Test with context
    context = {
        'distress_level': 'high',
        'previous_spiritual_mention': True,
        'patient_name': 'John'
    }
    
    contextual_result = generator.generate_consent_request(context=context)
    assert contextual_result['context_used'] == context, "Should record context used"
    assert len(contextual_result['message']) > 0, "Contextual message should not be empty"
    
    print("✓ Consent request generation works correctly")
    return True


def test_response_message_generation():
    """Test response message generation based on patient responses."""
    print("Testing response message generation...")
    
    generator = ConsentMessageGenerator()
    
    # Test acceptance response
    accept_response = "Yes, I would like to speak with someone"
    result = generator.generate_response_message(accept_response, "test_session_1")
    
    # Verify result structure
    assert 'action' in result, "Result should contain action"
    assert 'message' in result, "Result should contain response message"
    assert 'is_compliant' in result, "Result should contain compliance check"
    assert 'validation_score' in result, "Result should contain validation score"
    assert 'patient_response' in result, "Result should record patient response"
    
    # Verify acceptance handling
    assert result['action'] == 'proceed_with_referral', "Accept should proceed with referral"
    assert result['generate_provider_summary'] == True, "Accept should generate summary"
    assert result['patient_response'] == accept_response, "Should record original response"
    
    # Test decline response
    decline_response = "No, I'm fine"
    decline_result = generator.generate_response_message(decline_response, "test_session_2")
    
    assert decline_result['action'] == 'return_to_medical_dialogue', "Decline should return to medical"
    assert decline_result['generate_provider_summary'] == False, "Decline should not generate summary"
    
    # Test ambiguous response
    ambiguous_response = "I don't know, what would that involve?"
    ambiguous_result = generator.generate_response_message(ambiguous_response, "test_session_3")
    
    assert ambiguous_result['action'] == 'request_clarification', "Ambiguous should request clarification"
    assert ambiguous_result.get('requires_follow_up') == True, "Ambiguous should require follow-up"
    
    print("✓ Response message generation works correctly")
    return True


def test_consent_template_creation():
    """Test consent template creation and management."""
    print("Testing consent template creation...")
    
    generator = ConsentMessageGenerator()
    
    # Create a test template
    template_id = "test_template_1"
    template_name = "Test Initial Request"
    message_type = ConsentMessageType.INITIAL_REQUEST
    content = "Would you be interested in speaking with {team_type} if that would be helpful?"
    variables = ["team_type"]
    
    # Create template
    success = generator.create_consent_template(
        template_id, template_name, message_type, content, variables
    )
    
    assert success, "Template creation should succeed"
    assert template_id in generator.consent_templates, "Template should be stored"
    
    # Verify template properties
    template = generator.consent_templates[template_id]
    assert template.template_id == template_id, "Template ID should match"
    assert template.name == template_name, "Template name should match"
    assert template.content == content, "Template content should match"
    assert template.variables == variables, "Template variables should match"
    
    # Test template usage
    context = {"team_type": "our spiritual care team"}
    result = generator.generate_consent_request(context=context, template_id=template_id)
    
    assert "our spiritual care team" in result['message'], "Template should substitute variables"
    assert result['template_id'] == template_id, "Should record template used"
    
    # Test invalid template content
    try:
        generator.create_consent_template(
            "invalid_template",
            "Invalid Template",
            ConsentMessageType.INITIAL_REQUEST,
            "You need to speak with someone from spiritual care.",  # Non-compliant
            []
        )
        assert False, "Should raise ValueError for non-compliant template"
    except ValueError as e:
        assert "violates language compliance" in str(e), "Should indicate compliance violation"
    
    print("✓ Consent template creation works correctly")
    return True


def test_message_batch_validation():
    """Test batch validation of consent messages."""
    print("Testing message batch validation...")
    
    generator = ConsentMessageGenerator()
    
    # Create test messages (mix of compliant and non-compliant)
    test_messages = [
        "Would you be interested in speaking with someone from our spiritual care team?",  # Compliant
        "Our spiritual care team is available if you'd like to connect with them.",  # Compliant
        "You need to speak with someone from spiritual care.",  # Non-compliant
        "This will help you feel better.",  # Non-compliant
        "I understand and respect your decision.",  # Compliant
    ]
    
    # Validate batch
    results = generator.validate_message_batch(test_messages)
    
    # Verify results structure
    required_fields = ['total_messages', 'compliant_messages', 'non_compliant_messages',
                      'average_validation_score', 'common_violations', 'detailed_results']
    for field in required_fields:
        assert field in results, f"Results missing required field: {field}"
    
    # Verify counts
    assert results['total_messages'] == 5, "Should count all messages"
    assert results['compliant_messages'] == 3, "Should identify compliant messages"
    assert results['non_compliant_messages'] == 2, "Should identify non-compliant messages"
    
    # Verify detailed results
    assert len(results['detailed_results']) == 5, "Should have detailed results for all messages"
    
    for i, detail in enumerate(results['detailed_results']):
        assert detail['message_index'] == i, "Should have correct message index"
        assert 'message' in detail, "Should include original message"
        assert 'is_compliant' in detail, "Should include compliance status"
        assert 'validation_score' in detail, "Should include validation score"
    
    # Verify common violations tracking
    assert isinstance(results['common_violations'], dict), "Common violations should be dict"
    
    print("✓ Message batch validation works correctly")
    return True


def test_approved_patterns_access():
    """Test access to approved language patterns."""
    print("Testing approved patterns access...")
    
    generator = ConsentMessageGenerator()
    
    # Get approved patterns
    patterns = generator.get_approved_patterns()
    
    # Verify structure
    assert isinstance(patterns, dict), "Patterns should be dictionary"
    
    # Verify required pattern types
    required_types = ['initial_request', 'clarification', 'confirmation', 'decline_acknowledgment']
    for pattern_type in required_types:
        assert pattern_type in patterns, f"Missing pattern type: {pattern_type}"
        assert len(patterns[pattern_type]) > 0, f"Pattern type {pattern_type} should have examples"
    
    # Verify all patterns are strings
    for pattern_type, pattern_list in patterns.items():
        for pattern in pattern_list:
            assert isinstance(pattern, str), f"Pattern should be string: {pattern}"
            assert len(pattern) > 0, f"Pattern should not be empty: {pattern}"
    
    print("✓ Approved patterns access works correctly")
    return True


def test_validation_guidelines():
    """Test validation guidelines access."""
    print("Testing validation guidelines...")
    
    generator = ConsentMessageGenerator()
    
    # Get validation guidelines
    guidelines = generator.get_validation_guidelines()
    
    # Verify structure
    required_fields = ['non_assumptive_requirements', 'validation_rules', 
                      'respectful_language_indicators', 'message_types', 'response_types']
    for field in required_fields:
        assert field in guidelines, f"Guidelines missing required field: {field}"
    
    # Verify non-assumptive requirements
    requirements = guidelines['non_assumptive_requirements']
    assert 'avoid_assumptions' in requirements, "Should have assumption avoidance rules"
    assert 'avoid_pressure' in requirements, "Should have pressure avoidance rules"
    assert 'avoid_religious_assumptions' in requirements, "Should have religious assumption rules"
    
    # Verify message types
    message_types = guidelines['message_types']
    expected_types = ['initial_request', 'clarification', 'confirmation', 'decline_acknowledgment']
    for expected_type in expected_types:
        assert expected_type in message_types, f"Missing message type: {expected_type}"
    
    # Verify response types
    response_types = guidelines['response_types']
    expected_responses = ['accept', 'decline', 'ambiguous', 'unclear']
    for expected_response in expected_responses:
        assert expected_response in response_types, f"Missing response type: {expected_response}"
    
    print("✓ Validation guidelines work correctly")
    return True


def test_validation_score_calculation():
    """Test validation score calculation."""
    print("Testing validation score calculation...")
    
    generator = ConsentMessageGenerator()
    
    # Test high-scoring message
    good_message = "Would you be interested in speaking with someone if that would be helpful?"
    good_score = generator._calculate_validation_score(good_message)
    
    assert 0.0 <= good_score <= 1.0, "Score should be between 0 and 1"
    assert good_score > 0.5, "Good message should have high score"
    
    # Test low-scoring message
    bad_message = "You need to speak with God about your problems."
    bad_score = generator._calculate_validation_score(bad_message)
    
    assert 0.0 <= bad_score <= 1.0, "Score should be between 0 and 1"
    assert bad_score < good_score, "Bad message should have lower score than good message"
    
    # Test neutral message
    neutral_message = "I will contact someone for you."
    neutral_score = generator._calculate_validation_score(neutral_message)
    
    assert 0.0 <= neutral_score <= 1.0, "Score should be between 0 and 1"
    
    print("✓ Validation score calculation works correctly")
    return True


def main():
    """Run all consent message generator tests."""
    print("=" * 60)
    print("CONSENT MESSAGE GENERATOR TESTS")
    print("=" * 60)
    
    tests = [
        test_consent_message_generator_initialization,
        test_consent_request_generation,
        test_response_message_generation,
        test_consent_template_creation,
        test_message_batch_validation,
        test_approved_patterns_access,
        test_validation_guidelines,
        test_validation_score_calculation
    ]
    
    passed = 0
    failed = 0
    
    for test in tests:
        try:
            print(f"\n{test.__name__.replace('_', ' ').title()}:")
            print("-" * 40)
            
            result = test()
            if result:
                passed += 1
                print("✓ PASSED")
            else:
                failed += 1
                print("✗ FAILED")
                
        except Exception as e:
            failed += 1
            print(f"✗ FAILED: {str(e)}")
    
    print("\n" + "=" * 60)
    print(f"RESULTS: {passed} passed, {failed} failed")
    print("=" * 60)
    
    if failed == 0:
        print("🎉 All consent message generator tests passed!")
        print("\n**Task 5.2: Consent Message Generation Logic**")
        print("✓ COMPLETED: Approved language pattern validation")
        print("✓ COMPLETED: Non-assumptive language checking")
        print("✓ COMPLETED: Consent message template system")
        print("✓ COMPLETED: Batch validation capabilities")
        print("✓ VALIDATED: Requirements 4.1, 4.5")
        return True
    else:
        print("❌ Some tests failed. Please check the implementation.")
        return False


if __name__ == "__main__":
    success = main()
    sys.exit(0 if success else 1)