tests/unit/test_enhanced_display_config.py

#!/usr/bin/env python3
"""
Unit tests for Enhanced Display Configuration System.

Tests the configuration system for UI classification improvements
including feature toggles, styling options, and configuration management.

Requirements: 7.1, 7.2, 7.3
"""

import unittest
import tempfile
import os
import json
from unittest.mock import patch, MagicMock

import sys
current_dir = os.path.dirname(os.path.abspath(__file__))
src_dir = os.path.join(os.path.dirname(os.path.dirname(current_dir)), 'src')
if src_dir not in sys.path:
    sys.path.insert(0, src_dir)

from config.enhanced_display_config import (
    EnhancedDisplayConfig,
    EnhancedDisplayConfigManager,
    SectionStylingConfig,
    ClassificationColorConfig,
    VisualSeparatorConfig,
    create_high_contrast_config,
    create_minimal_config,
    create_mobile_optimized_config
)


class TestEnhancedDisplayConfig(unittest.TestCase):
    """Test cases for EnhancedDisplayConfig class."""
    
    def setUp(self):
        """Set up test fixtures."""
        self.config = EnhancedDisplayConfig()
    
    def test_default_configuration(self):
        """Test default configuration values."""
        # Test feature toggles
        self.assertTrue(self.config.enabled)
        self.assertTrue(self.config.use_color_coding)
        self.assertTrue(self.config.use_icons)
        self.assertTrue(self.config.use_visual_separators)
        self.assertTrue(self.config.use_enhanced_styling)
        
        # Test default icons
        self.assertEqual(self.config.ai_analysis.icon, "🤖")
        self.assertEqual(self.config.patient_message.icon, "💬")
        self.assertEqual(self.config.provider_summary.icon, "📋")
        
        # Test default colors
        self.assertEqual(self.config.classification_colors.red, "#ff4444")
        self.assertEqual(self.config.classification_colors.yellow, "#ffaa00")
        self.assertEqual(self.config.classification_colors.green, "#44aa44")
    
    def test_get_classification_color(self):
        """Test classification color retrieval."""
        self.assertEqual(self.config.get_classification_color("RED"), "#ff4444")
        self.assertEqual(self.config.get_classification_color("red"), "#ff4444")
        self.assertEqual(self.config.get_classification_color("YELLOW"), "#ffaa00")
        self.assertEqual(self.config.get_classification_color("GREEN"), "#44aa44")
        self.assertEqual(self.config.get_classification_color("UNKNOWN"), "#666666")
    
    def test_get_section_config(self):
        """Test section configuration retrieval."""
        ai_config = self.config.get_section_config("ai_analysis")
        self.assertIsInstance(ai_config, SectionStylingConfig)
        self.assertEqual(ai_config.icon, "🤖")
        
        patient_config = self.config.get_section_config("patient_message")
        self.assertEqual(patient_config.icon, "💬")
        
        provider_config = self.config.get_section_config("provider_summary")
        self.assertEqual(provider_config.icon, "📋")
        
        # Test unknown section returns default
        unknown_config = self.config.get_section_config("unknown")
        self.assertEqual(unknown_config, self.config.ai_analysis)
    
    def test_high_contrast_mode(self):
        """Test high contrast mode application."""
        config = EnhancedDisplayConfig(high_contrast_mode=True)
        
        # Check that high contrast colors are applied
        self.assertEqual(config.classification_colors.red, "#cc0000")
        self.assertEqual(config.classification_colors.yellow, "#cc8800")
        self.assertEqual(config.classification_colors.green, "#006600")
        
        # Check section colors are updated
        self.assertEqual(config.ai_analysis.border_color, "#000000")
        self.assertEqual(config.ai_analysis.background_color, "#ffffff")
    
    def test_css_variables_generation(self):
        """Test CSS variables generation."""
        css_vars = self.config.generate_css_variables()
        
        # Check that CSS variables are generated
        self.assertIn(":root {", css_vars)
        self.assertIn("--enhanced-font-family:", css_vars)
        self.assertIn("--classification-red:", css_vars)
        self.assertIn("--ai-analysis-icon:", css_vars)
        self.assertIn("}", css_vars)
    
    def test_base_css_generation(self):
        """Test base CSS generation."""
        base_css = self.config.generate_base_css()
        
        # Check that CSS classes are generated
        self.assertIn(".enhanced-section", base_css)
        self.assertIn(".enhanced-section-header", base_css)
        self.assertIn(".ai-analysis-section", base_css)
        self.assertIn(".patient-message-section", base_css)
        self.assertIn(".provider-summary-section", base_css)
        
        # Check responsive design
        self.assertIn("@media", base_css)
    
    def test_to_dict_conversion(self):
        """Test conversion to dictionary."""
        config_dict = self.config.to_dict()
        
        self.assertIsInstance(config_dict, dict)
        self.assertEqual(config_dict['enabled'], True)
        self.assertEqual(config_dict['use_color_coding'], True)
        self.assertIn('ai_analysis', config_dict)
        self.assertIn('classification_colors', config_dict)
    
    def test_to_json_conversion(self):
        """Test conversion to JSON."""
        config_json = self.config.to_json()
        
        # Should be valid JSON
        parsed = json.loads(config_json)
        self.assertIsInstance(parsed, dict)
        self.assertEqual(parsed['enabled'], True)


class TestEnhancedDisplayConfigManager(unittest.TestCase):
    """Test cases for EnhancedDisplayConfigManager class."""
    
    def setUp(self):
        """Set up test fixtures."""
        # Create temporary config file
        self.temp_dir = tempfile.mkdtemp()
        self.config_file = os.path.join(self.temp_dir, "test_config.json")
        self.config_manager = EnhancedDisplayConfigManager(self.config_file)
    
    def tearDown(self):
        """Clean up test fixtures."""
        # Clean up temporary files
        if os.path.exists(self.config_file):
            os.remove(self.config_file)
        os.rmdir(self.temp_dir)
    
    def test_load_default_config(self):
        """Test loading default configuration when no file exists."""
        config = self.config_manager.load_config()
        
        self.assertIsInstance(config, EnhancedDisplayConfig)
        self.assertTrue(config.enabled)
        self.assertTrue(os.path.exists(self.config_file))
    
    def test_save_and_load_config(self):
        """Test saving and loading configuration."""
        # Load and modify config
        config = self.config_manager.load_config()
        config.enabled = False
        config.use_icons = False
        
        # Save config
        success = self.config_manager.save_config()
        self.assertTrue(success)
        
        # Create new manager and load
        new_manager = EnhancedDisplayConfigManager(self.config_file)
        loaded_config = new_manager.load_config()
        
        self.assertFalse(loaded_config.enabled)
        self.assertFalse(loaded_config.use_icons)
    
    def test_update_config(self):
        """Test configuration updates."""
        success = self.config_manager.update_config(
            enabled=False,
            use_color_coding=False,
            use_icons=False
        )
        self.assertTrue(success)
        
        config = self.config_manager.load_config()
        self.assertFalse(config.enabled)
        self.assertFalse(config.use_color_coding)
        self.assertFalse(config.use_icons)
    
    def test_enable_disable_features(self):
        """Test feature enable/disable functionality."""
        # Disable color coding
        success = self.config_manager.disable_feature('color_coding')
        self.assertTrue(success)
        
        config = self.config_manager.load_config()
        self.assertFalse(config.use_color_coding)
        
        # Enable color coding
        success = self.config_manager.enable_feature('color_coding')
        self.assertTrue(success)
        
        config = self.config_manager.load_config()
        self.assertTrue(config.use_color_coding)
    
    def test_reset_to_defaults(self):
        """Test resetting configuration to defaults."""
        # Modify config
        self.config_manager.update_config(enabled=False, use_icons=False)
        
        # Reset to defaults
        success = self.config_manager.reset_to_defaults()
        self.assertTrue(success)
        
        config = self.config_manager.load_config()
        self.assertTrue(config.enabled)
        self.assertTrue(config.use_icons)
    
    def test_validate_config(self):
        """Test configuration validation."""
        # Valid configuration should have no issues
        issues = self.config_manager.validate_config()
        self.assertEqual(len(issues), 0)
        
        # Test with invalid color (this would need to be implemented)
        # For now, just test that validation runs without error
        self.assertIsInstance(issues, list)
    
    def test_config_file_error_handling(self):
        """Test error handling for config file operations."""
        # Test with invalid config file path
        invalid_manager = EnhancedDisplayConfigManager("/invalid/path/config.json")
        
        # Should still return default config
        config = invalid_manager.load_config()
        self.assertIsInstance(config, EnhancedDisplayConfig)
        self.assertTrue(config.enabled)


class TestPresetConfigurations(unittest.TestCase):
    """Test cases for preset configuration functions."""
    
    def test_high_contrast_config(self):
        """Test high contrast configuration preset."""
        config = create_high_contrast_config()
        
        self.assertTrue(config.high_contrast_mode)
        self.assertEqual(config.classification_colors.red, "#cc0000")
        self.assertEqual(config.ai_analysis.border_color, "#000000")
    
    def test_minimal_config(self):
        """Test minimal configuration preset."""
        config = create_minimal_config()
        
        self.assertFalse(config.use_icons)
        self.assertFalse(config.use_visual_separators)
        self.assertFalse(config.enable_animations)
    
    def test_mobile_optimized_config(self):
        """Test mobile optimized configuration preset."""
        config = create_mobile_optimized_config()
        
        self.assertEqual(config.responsive_breakpoint, "480px")
        self.assertEqual(config.ai_analysis.padding, "12px")
        self.assertFalse(config.enable_animations)


class TestSectionStylingConfig(unittest.TestCase):
    """Test cases for SectionStylingConfig class."""
    
    def test_default_values(self):
        """Test default section styling values."""
        config = SectionStylingConfig(
            icon="🔧",
            border_color="#000000",
            background_color="#ffffff",
            header_color="#000000"
        )
        
        self.assertEqual(config.icon, "🔧")
        self.assertEqual(config.border_width, "2px")
        self.assertEqual(config.border_radius, "8px")
        self.assertEqual(config.padding, "15px")
        self.assertEqual(config.margin, "10px 0")


class TestClassificationColorConfig(unittest.TestCase):
    """Test cases for ClassificationColorConfig class."""
    
    def test_default_colors(self):
        """Test default classification colors."""
        config = ClassificationColorConfig()
        
        self.assertEqual(config.red, "#ff4444")
        self.assertEqual(config.yellow, "#ffaa00")
        self.assertEqual(config.green, "#44aa44")
        self.assertEqual(config.unknown, "#666666")


class TestVisualSeparatorConfig(unittest.TestCase):
    """Test cases for VisualSeparatorConfig class."""
    
    def test_default_separators(self):
        """Test default visual separator values."""
        config = VisualSeparatorConfig()
        
        self.assertEqual(config.section_separator, "---")
        self.assertEqual(config.content_divider, "1px solid #ddd")
        self.assertEqual(config.major_break_symbol, "● ● ●")
        self.assertEqual(config.separator_color, "#e0e0e0")
        self.assertEqual(config.separator_width, "80%")


if __name__ == '__main__':
    unittest.main()