pomera-ai-commander 1.1.1 → 1.2.2

package/core/migration_validator.py

@@ -1,1144 +1,1144 @@
-"""
-Migration Validation System for Settings Database Migration
-
-This module provides comprehensive validation and testing capabilities for the
-migration system, including data integrity checks, edge case testing, and
-rollback procedures for all tool configurations.
-
-Designed to validate all 15+ tool configurations and complex data structures
-identified in the production codebase analysis.
-"""
-
-import json
-import sqlite3
-import os
-import shutil
-import logging
-import tempfile
-import hashlib
-from typing import Dict, List, Tuple, Any, Optional, Union, Set
-from datetime import datetime
-from pathlib import Path
-from dataclasses import dataclass
-
-from .migration_manager import MigrationManager
-from .database_connection_manager import DatabaseConnectionManager
-from .database_schema_manager import DatabaseSchemaManager
-
-
-@dataclass
-class ValidationResult:
-    """Result of a validation operation."""
-    success: bool
-    errors: List[str]
-    warnings: List[str]
-    details: Dict[str, Any]
-    
-    def add_error(self, error: str) -> None:
-        """Add an error to the result."""
-        self.errors.append(error)
-        self.success = False
-    
-    def add_warning(self, warning: str) -> None:
-        """Add a warning to the result."""
-        self.warnings.append(warning)
-    
-    def merge(self, other: 'ValidationResult') -> None:
-        """Merge another validation result into this one."""
-        self.errors.extend(other.errors)
-        self.warnings.extend(other.warnings)
-        self.details.update(other.details)
-        if not other.success:
-            self.success = False
-
-
-class MigrationValidator:
-    """
-    Comprehensive migration validation and testing system.
-    
-    Features:
-    - Data integrity validation for all tool configurations
-    - Edge case testing (corrupted JSON, missing fields, invalid data)
-    - Automatic backup creation and rollback procedures
-    - Performance testing for large settings files
-    - Comprehensive test suite for all 15+ tool types
-    """
-    
-    def __init__(self, migration_manager: MigrationManager):
-        """
-        Initialize the migration validator.
-        
-        Args:
-            migration_manager: MigrationManager instance to validate
-        """
-        self.migration_manager = migration_manager
-        self.logger = logging.getLogger(__name__)
-        
-        # Test configuration
-        self._test_data_dir = None
-        self._backup_dir = None
-        self._temp_files = []
-        
-        # Validation settings
-        self._strict_validation = True
-        self._validate_types = True
-        self._validate_structure = True
-        self._validate_content = True
-        
-        # Known tool configurations from production analysis
-        self._known_tools = {
-            'AI Tools', 'Base64 Encoder/Decoder', 'Case Tool', 'Cron Tool', 'Diff Viewer',
-            'Email Extraction Tool', 'Email Header Analyzer', 'Find & Replace Text', 
-            'Folder File Reporter', 'Generator Tools', 'HTML Extraction Tool', 
-            'JSON/XML Tool', 'Sorter Tools', 'Translator Tools', 'URL Parser', 
-            'URL and Link Extractor', 'Word Frequency Counter',
-            # AI Provider configurations (stored as separate tool settings)
-            'Google AI', 'Anthropic AI', 'OpenAI', 'AWS Bedrock', 'Cohere AI', 
-            'HuggingFace AI', 'Groq AI', 'OpenRouterAI', 'LM Studio'
-        }
-        
-        # Critical settings that must be preserved
-        self._critical_settings = {
-            'export_path', 'debug_level', 'selected_tool',
-            'active_input_tab', 'active_output_tab',
-            'input_tabs', 'output_tabs', 'tool_settings'
-        }
-    
-    def validate_complete_migration(self, json_filepath: str) -> ValidationResult:
-        """
-        Perform comprehensive validation of a complete migration cycle.
-        
-        Args:
-            json_filepath: Path to source JSON settings file
-            
-        Returns:
-            ValidationResult with comprehensive validation details
-        """
-        result = ValidationResult(True, [], [], {})
-        
-        try:
-            self.logger.info(f"Starting comprehensive migration validation: {json_filepath}")
-            
-            # Step 1: Validate source JSON file
-            source_validation = self._validate_source_json(json_filepath)
-            result.merge(source_validation)
-            
-            if not source_validation.success and self._strict_validation:
-                return result
-            
-            # Step 2: Create backup and test environment
-            backup_result = self._setup_test_environment(json_filepath)
-            result.merge(backup_result)
-            
-            # Step 3: Perform migration to database
-            migration_result = self._test_json_to_database_migration(json_filepath)
-            result.merge(migration_result)
-            
-            # Step 4: Validate database content
-            if migration_result.success:
-                db_validation = self._validate_database_content()
-                result.merge(db_validation)
-            
-            # Step 5: Test reverse migration
-            if migration_result.success:
-                reverse_result = self._test_database_to_json_migration()
-                result.merge(reverse_result)
-            
-            # Step 6: Validate round-trip accuracy
-            if reverse_result.success:
-                roundtrip_result = self._validate_roundtrip_accuracy(json_filepath)
-                result.merge(roundtrip_result)
-            
-            # Step 7: Test edge cases
-            edge_case_result = self._test_edge_cases()
-            result.merge(edge_case_result)
-            
-            # Step 8: Performance testing
-            performance_result = self._test_performance()
-            result.merge(performance_result)
-            
-            result.details['validation_summary'] = {
-                'total_tests': 8,
-                'passed_tests': sum(1 for r in [source_validation, backup_result, migration_result, 
-                                               db_validation, reverse_result, roundtrip_result,
-                                               edge_case_result, performance_result] if r.success),
-                'total_errors': len(result.errors),
-                'total_warnings': len(result.warnings)
-            }
-            
-            self.logger.info("Comprehensive migration validation completed")
-            return result
-            
-        except Exception as e:
-            result.add_error(f"Validation failed with exception: {e}")
-            self.logger.error(f"Migration validation error: {e}")
-            return result
-        
-        finally:
-            self._cleanup_test_environment()
-    
-    def validate_tool_configurations(self) -> ValidationResult:
-        """
-        Validate all known tool configurations for migration compatibility.
-        
-        Returns:
-            ValidationResult with tool-specific validation details
-        """
-        result = ValidationResult(True, [], [], {})
-        
-        try:
-            self.logger.info("Validating all tool configurations")
-            
-            # Create test data for each known tool
-            test_configs = self._generate_test_tool_configurations()
-            
-            for tool_name, tool_config in test_configs.items():
-                tool_result = self._validate_single_tool_configuration(tool_name, tool_config)
-                result.merge(tool_result)
-                
-                result.details[f'tool_{tool_name.replace(" ", "_")}'] = {
-                    'success': tool_result.success,
-                    'errors': tool_result.errors,
-                    'warnings': tool_result.warnings
-                }
-            
-            result.details['tool_validation_summary'] = {
-                'total_tools': len(test_configs),
-                'successful_tools': sum(1 for tool in result.details.values() 
-                                      if isinstance(tool, dict) and tool.get('success', False)),
-                'failed_tools': sum(1 for tool in result.details.values() 
-                                  if isinstance(tool, dict) and not tool.get('success', True))
-            }
-            
-            self.logger.info("Tool configuration validation completed")
-            return result
-            
-        except Exception as e:
-            result.add_error(f"Tool validation failed: {e}")
-            return result
-    
-    def test_edge_cases(self) -> ValidationResult:
-        """
-        Test migration with various edge cases and malformed data.
-        
-        Returns:
-            ValidationResult with edge case test results
-        """
-        result = ValidationResult(True, [], [], {})
-        
-        try:
-            self.logger.info("Testing migration edge cases")
-            
-            # Test cases for edge scenarios
-            edge_cases = [
-                ('empty_json', {}),
-                ('missing_tool_settings', {'export_path': 'test'}),
-                ('corrupted_nested_structure', {'tool_settings': {'invalid': None}}),
-                ('large_data_structure', self._generate_large_test_data()),
-                ('unicode_content', self._generate_unicode_test_data()),
-                ('encrypted_keys', self._generate_encrypted_test_data()),
-                ('invalid_types', self._generate_invalid_type_data()),
-                ('missing_tabs', {'tool_settings': {}}),
-                ('extra_fields', self._generate_extra_fields_data())
-            ]
-            
-            for case_name, test_data in edge_cases:
-                case_result = self._test_single_edge_case(case_name, test_data)
-                result.merge(case_result)
-                
-                result.details[f'edge_case_{case_name}'] = {
-                    'success': case_result.success,
-                    'errors': case_result.errors,
-                    'warnings': case_result.warnings
-                }
-            
-            result.details['edge_case_summary'] = {
-                'total_cases': len(edge_cases),
-                'passed_cases': sum(1 for case in result.details.values() 
-                                  if isinstance(case, dict) and case.get('success', False)),
-                'failed_cases': sum(1 for case in result.details.values() 
-                                  if isinstance(case, dict) and not case.get('success', True))
-            }
-            
-            self.logger.info("Edge case testing completed")
-            return result
-            
-        except Exception as e:
-            result.add_error(f"Edge case testing failed: {e}")
-            return result
-    
-    def create_automatic_backup(self, json_filepath: str) -> Tuple[bool, Optional[str]]:
-        """
-        Create automatic backup before migration with validation.
-        
-        Args:
-            json_filepath: Path to JSON file to backup
-            
-        Returns:
-            Tuple of (success, backup_path)
-        """
-        try:
-            if not os.path.exists(json_filepath):
-                self.logger.error(f"Source file not found: {json_filepath}")
-                return False, None
-            
-            # Generate backup path with timestamp
-            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-            backup_path = f"{json_filepath}.backup_{timestamp}"
-            
-            # Create backup
-            shutil.copy2(json_filepath, backup_path)
-            
-            # Validate backup integrity
-            if self._validate_backup_integrity(json_filepath, backup_path):
-                self.logger.info(f"Automatic backup created: {backup_path}")
-                return True, backup_path
-            else:
-                self.logger.error("Backup integrity validation failed")
-                return False, None
-                
-        except Exception as e:
-            self.logger.error(f"Automatic backup failed: {e}")
-            return False, None
-    
-    def test_rollback_procedures(self, backup_filepath: str) -> ValidationResult:
-        """
-        Test rollback procedures for failed migrations.
-        
-        Args:
-            backup_filepath: Path to backup file for rollback testing
-            
-        Returns:
-            ValidationResult with rollback test results
-        """
-        result = ValidationResult(True, [], [], {})
-        
-        try:
-            self.logger.info(f"Testing rollback procedures: {backup_filepath}")
-            
-            if not os.path.exists(backup_filepath):
-                result.add_error(f"Backup file not found: {backup_filepath}")
-                return result
-            
-            # Test rollback functionality
-            rollback_success = self.migration_manager.rollback_migration(backup_filepath)
-            
-            if rollback_success:
-                result.details['rollback_test'] = {
-                    'success': True,
-                    'backup_file': backup_filepath,
-                    'rollback_time': datetime.now().isoformat()
-                }
-            else:
-                result.add_error("Rollback procedure failed")
-                result.details['rollback_test'] = {
-                    'success': False,
-                    'backup_file': backup_filepath,
-                    'error': 'Rollback operation failed'
-                }
-            
-            # Validate restored file integrity
-            if rollback_success:
-                integrity_result = self._validate_rollback_integrity(backup_filepath)
-                result.merge(integrity_result)
-            
-            self.logger.info("Rollback procedure testing completed")
-            return result
-            
-        except Exception as e:
-            result.add_error(f"Rollback testing failed: {e}")
-            return result
-    
-    # Private implementation methods
-    
-    def _validate_source_json(self, json_filepath: str) -> ValidationResult:
-        """Validate source JSON file structure and content."""
-        result = ValidationResult(True, [], [], {})
-        
-        try:
-            if not os.path.exists(json_filepath):
-                result.add_error(f"JSON file not found: {json_filepath}")
-                return result
-            
-            # Load and parse JSON
-            with open(json_filepath, 'r', encoding='utf-8') as f:
-                data = json.load(f)
-            
-            # Validate critical settings exist
-            for setting in self._critical_settings:
-                if setting not in data:
-                    if setting in ['input_tabs', 'output_tabs', 'tool_settings']:
-                        result.add_warning(f"Missing critical setting: {setting}")
-                    else:
-                        result.add_error(f"Missing critical setting: {setting}")
-            
-            # Validate tool settings structure
-            if 'tool_settings' in data:
-                tool_validation = self._validate_tool_settings_structure(data['tool_settings'])
-                result.merge(tool_validation)
-            
-            # Validate tab arrays
-            if 'input_tabs' in data:
-                tab_validation = self._validate_tab_arrays(data['input_tabs'], 'input_tabs')
-                result.merge(tab_validation)
-            
-            if 'output_tabs' in data:
-                tab_validation = self._validate_tab_arrays(data['output_tabs'], 'output_tabs')
-                result.merge(tab_validation)
-            
-            result.details['source_validation'] = {
-                'file_size': os.path.getsize(json_filepath),
-                'tool_count': len(data.get('tool_settings', {})),
-                'has_critical_settings': all(s in data for s in self._critical_settings)
-            }
-            
-            return result
-            
-        except json.JSONDecodeError as e:
-            result.add_error(f"Invalid JSON format: {e}")
-            return result
-        except Exception as e:
-            result.add_error(f"Source validation failed: {e}")
-            return result
-    
-    def _setup_test_environment(self, json_filepath: str) -> ValidationResult:
-        """Setup test environment with temporary directories and backups."""
-        result = ValidationResult(True, [], [], {})
-        
-        try:
-            # Create temporary test directory
-            self._test_data_dir = tempfile.mkdtemp(prefix="migration_test_")
-            self._backup_dir = os.path.join(self._test_data_dir, "backups")
-            os.makedirs(self._backup_dir, exist_ok=True)
-            
-            # Create backup
-            backup_success, backup_path = self.create_automatic_backup(json_filepath)
-            if backup_success:
-                result.details['backup_created'] = backup_path
-            else:
-                result.add_error("Failed to create test backup")
-            
-            result.details['test_environment'] = {
-                'test_dir': self._test_data_dir,
-                'backup_dir': self._backup_dir,
-                'setup_time': datetime.now().isoformat()
-            }
-            
-            return result
-            
-        except Exception as e:
-            result.add_error(f"Test environment setup failed: {e}")
-            return result
-    
-    def _test_json_to_database_migration(self, json_filepath: str) -> ValidationResult:
-        """Test JSON to database migration process."""
-        result = ValidationResult(True, [], [], {})
-        
-        try:
-            # Perform migration
-            migration_success = self.migration_manager.migrate_from_json(json_filepath, validate=True)
-            
-            if migration_success:
-                result.details['json_to_db_migration'] = {
-                    'success': True,
-                    'migration_time': datetime.now().isoformat()
-                }
-            else:
-                result.add_error("JSON to database migration failed")
-                result.details['json_to_db_migration'] = {
-                    'success': False,
-                    'error': 'Migration operation failed'
-                }
-            
-            return result
-            
-        except Exception as e:
-            result.add_error(f"JSON to database migration test failed: {e}")
-            return result
-    
-    def _validate_database_content(self) -> ValidationResult:
-        """Validate database content after migration."""
-        result = ValidationResult(True, [], [], {})
-        
-        try:
-            conn = self.migration_manager.connection_manager.get_connection()
-            
-            # Check all tables exist and have data
-            tables = ['core_settings', 'tool_settings', 'tab_content', 
-                     'performance_settings', 'font_settings', 'dialog_settings']
-            
-            for table in tables:
-                cursor = conn.execute(f"SELECT COUNT(*) FROM {table}")
-                count = cursor.fetchone()[0]
-                
-                result.details[f'{table}_count'] = count
-                
-                if table in ['core_settings', 'tool_settings'] and count == 0:
-                    result.add_warning(f"Table {table} is empty")
-            
-            # Validate data types and structure
-            type_validation = self._validate_database_types(conn)
-            result.merge(type_validation)
-            
-            return result
-            
-        except Exception as e:
-            result.add_error(f"Database content validation failed: {e}")
-            return result
-    
-    def _test_database_to_json_migration(self) -> ValidationResult:
-        """Test database to JSON migration process."""
-        result = ValidationResult(True, [], [], {})
-        
-        try:
-            # Create temporary JSON file for reverse migration
-            temp_json = os.path.join(self._test_data_dir, "reverse_migration.json")
-            
-            # Perform reverse migration
-            migration_success = self.migration_manager.migrate_to_json(temp_json, validate=True)
-            
-            if migration_success:
-                result.details['db_to_json_migration'] = {
-                    'success': True,
-                    'output_file': temp_json,
-                    'migration_time': datetime.now().isoformat()
-                }
-                self._temp_files.append(temp_json)
-            else:
-                result.add_error("Database to JSON migration failed")
-                result.details['db_to_json_migration'] = {
-                    'success': False,
-                    'error': 'Reverse migration operation failed'
-                }
-            
-            return result
-            
-        except Exception as e:
-            result.add_error(f"Database to JSON migration test failed: {e}")
-            return result
-    
-    def _validate_roundtrip_accuracy(self, original_json: str) -> ValidationResult:
-        """Validate round-trip migration accuracy."""
-        result = ValidationResult(True, [], [], {})
-        
-        try:
-            # Load original data
-            with open(original_json, 'r', encoding='utf-8') as f:
-                original_data = json.load(f)
-            
-            # Load migrated data
-            migrated_json = os.path.join(self._test_data_dir, "reverse_migration.json")
-            if not os.path.exists(migrated_json):
-                result.add_error("Migrated JSON file not found for comparison")
-                return result
-            
-            with open(migrated_json, 'r', encoding='utf-8') as f:
-                migrated_data = json.load(f)
-            
-            # Deep comparison
-            comparison_result = self._deep_compare_data(original_data, migrated_data)
-            result.merge(comparison_result)
-            
-            # Calculate data integrity metrics
-            integrity_metrics = self._calculate_integrity_metrics(original_data, migrated_data)
-            result.details['integrity_metrics'] = integrity_metrics
-            
-            return result
-            
-        except Exception as e:
-            result.add_error(f"Round-trip accuracy validation failed: {e}")
-            return result
-    
-    def _test_edge_cases(self) -> ValidationResult:
-        """Test various edge cases and error conditions."""
-        result = ValidationResult(True, [], [], {})
-        
-        # This is a placeholder - the actual implementation would be in test_edge_cases()
-        # which is already implemented above
-        edge_case_result = self.test_edge_cases()
-        result.merge(edge_case_result)
-        
-        return result
-    
-    def _test_performance(self) -> ValidationResult:
-        """Test migration performance with various data sizes."""
-        result = ValidationResult(True, [], [], {})
-        
-        try:
-            # Test with different data sizes
-            test_sizes = [
-                ('small', 10),      # 10 tools
-                ('medium', 50),     # 50 tools  
-                ('large', 100),     # 100 tools
-                ('xlarge', 500)     # 500 tools
-            ]
-            
-            for size_name, tool_count in test_sizes:
-                perf_result = self._test_migration_performance(size_name, tool_count)
-                result.merge(perf_result)
-                result.details[f'performance_{size_name}'] = perf_result.details
-            
-            return result
-            
-        except Exception as e:
-            result.add_error(f"Performance testing failed: {e}")
-            return result
-    
-    def _cleanup_test_environment(self) -> None:
-        """Clean up temporary test files and directories."""
-        try:
-            # Remove temporary files
-            for temp_file in self._temp_files:
-                if os.path.exists(temp_file):
-                    os.remove(temp_file)
-            
-            # Remove test directory
-            if self._test_data_dir and os.path.exists(self._test_data_dir):
-                shutil.rmtree(self._test_data_dir)
-            
-            self.logger.debug("Test environment cleaned up")
-            
-        except Exception as e:
-            self.logger.warning(f"Test cleanup failed: {e}")
-    
-    def _validate_tool_settings_structure(self, tool_settings: Dict[str, Any]) -> ValidationResult:
-        """Validate tool settings structure and known tools."""
-        result = ValidationResult(True, [], [], {})
-        
-        try:
-            # Check for known tools
-            found_tools = set(tool_settings.keys())
-            unknown_tools = found_tools - self._known_tools
-            
-            if unknown_tools:
-                result.add_warning(f"Unknown tools found: {unknown_tools}")
-            
-            # Validate each tool configuration
-            for tool_name, tool_config in tool_settings.items():
-                if not isinstance(tool_config, dict):
-                    result.add_error(f"Tool {tool_name} has invalid configuration type: {type(tool_config)}")
-                    continue
-                
-                # Tool-specific validation
-                tool_result = self._validate_specific_tool(tool_name, tool_config)
-                result.merge(tool_result)
-            
-            result.details['tool_structure_validation'] = {
-                'total_tools': len(tool_settings),
-                'known_tools': len(found_tools & self._known_tools),
-                'unknown_tools': len(unknown_tools)
-            }
-            
-            return result
-            
-        except Exception as e:
-            result.add_error(f"Tool settings validation failed: {e}")
-            return result
-    
-    def _validate_tab_arrays(self, tab_data: List[str], tab_type: str) -> ValidationResult:
-        """Validate tab array structure and content."""
-        result = ValidationResult(True, [], [], {})
-        
-        try:
-            if not isinstance(tab_data, list):
-                result.add_error(f"{tab_type} is not a list: {type(tab_data)}")
-                return result
-            
-            # Check tab count (should be 7)
-            if len(tab_data) != 7:
-                result.add_warning(f"{tab_type} has {len(tab_data)} tabs, expected 7")
-            
-            # Check tab content types
-            for i, content in enumerate(tab_data):
-                if not isinstance(content, str):
-                    result.add_error(f"{tab_type}[{i}] is not a string: {type(content)}")
-            
-            result.details[f'{tab_type}_validation'] = {
-                'tab_count': len(tab_data),
-                'non_empty_tabs': sum(1 for tab in tab_data if tab.strip()),
-                'total_content_length': sum(len(tab) for tab in tab_data)
-            }
-            
-            return result
-            
-        except Exception as e:
-            result.add_error(f"Tab array validation failed: {e}")
-            return result
-    
-    def _validate_specific_tool(self, tool_name: str, tool_config: Dict[str, Any]) -> ValidationResult:
-        """Validate specific tool configuration based on known patterns."""
-        result = ValidationResult(True, [], [], {})
-        
-        try:
-            # AI tools validation
-            if any(ai_name in tool_name for ai_name in ['AI', 'Google', 'Anthropic', 'OpenAI', 'Cohere', 'HuggingFace', 'Groq', 'OpenRouter', 'AWS Bedrock', 'LM Studio']):
-                ai_result = self._validate_ai_tool_config(tool_name, tool_config)
-                result.merge(ai_result)
-            
-            # cURL tool validation
-            elif tool_name == 'cURL Tool':
-                curl_result = self._validate_curl_tool_config(tool_config)
-                result.merge(curl_result)
-            
-            # Generator tools validation
-            elif tool_name == 'Generator Tools':
-                gen_result = self._validate_generator_tools_config(tool_config)
-                result.merge(gen_result)
-            
-            # Other tool validations can be added here
-            
-            return result
-            
-        except Exception as e:
-            result.add_error(f"Specific tool validation failed for {tool_name}: {e}")
-            return result
-    
-    def _validate_ai_tool_config(self, tool_name: str, config: Dict[str, Any]) -> ValidationResult:
-        """Validate AI tool configuration."""
-        result = ValidationResult(True, [], [], {})
-        
-        # Check for required AI tool fields
-        required_fields = ['API_KEY', 'MODEL']
-        for field in required_fields:
-            if field not in config:
-                result.add_error(f"AI tool {tool_name} missing required field: {field}")
-        
-        # Check for encrypted API keys
-        if 'API_KEY' in config and config['API_KEY'].startswith('ENC:'):
-            result.details[f'{tool_name}_encrypted'] = True
-        
-        # Check model list
-        if 'MODELS_LIST' in config and isinstance(config['MODELS_LIST'], list):
-            result.details[f'{tool_name}_model_count'] = len(config['MODELS_LIST'])
-        
-        return result
-    
-    def _validate_curl_tool_config(self, config: Dict[str, Any]) -> ValidationResult:
-        """Validate cURL tool configuration."""
-        result = ValidationResult(True, [], [], {})
-        
-        # Check for history array
-        if 'history' in config:
-            if isinstance(config['history'], list):
-                result.details['curl_history_count'] = len(config['history'])
-                
-                # Validate history entries
-                for i, entry in enumerate(config['history']):
-                    if not isinstance(entry, dict):
-                        result.add_error(f"cURL history entry {i} is not a dict")
-                        continue
-                    
-                    required_history_fields = ['timestamp', 'method', 'url', 'status_code']
-                    for field in required_history_fields:
-                        if field not in entry:
-                            result.add_warning(f"cURL history entry {i} missing field: {field}")
-            else:
-                result.add_error("cURL history is not a list")
-        
-        return result
-    
-    def _validate_generator_tools_config(self, config: Dict[str, Any]) -> ValidationResult:
-        """Validate Generator Tools nested configuration."""
-        result = ValidationResult(True, [], [], {})
-        
-        # Check for nested tool configurations
-        expected_generators = [
-            'Strong Password Generator', 'Repeating Text Generator',
-            'Lorem Ipsum Generator', 'UUID/GUID Generator'
-        ]
-        
-        for generator in expected_generators:
-            if generator in config:
-                if not isinstance(config[generator], dict):
-                    result.add_error(f"Generator {generator} config is not a dict")
-            else:
-                result.add_warning(f"Generator {generator} not found in config")
-        
-        result.details['generator_tools_count'] = len(config)
-        
-        return result
-    
-    def _generate_test_tool_configurations(self) -> Dict[str, Dict[str, Any]]:
-        """Generate test configurations for all known tools."""
-        return {
-            'Test AI Tool': {
-                'API_KEY': 'test_key',
-                'MODEL': 'test_model',
-                'MODELS_LIST': ['model1', 'model2'],
-                'temperature': 0.7
-            },
-            'Test cURL Tool': {
-                'default_timeout': 30,
-                'history': [
-                    {
-                        'timestamp': '2025-01-01T00:00:00',
-                        'method': 'GET',
-                        'url': 'https://test.com',
-                        'status_code': 200
-                    }
-                ]
-            },
-            'Test Generator Tools': {
-                'Password Generator': {
-                    'length': 12,
-                    'symbols': True
-                }
-            }
-        }
-    
-    def _validate_single_tool_configuration(self, tool_name: str, tool_config: Dict[str, Any]) -> ValidationResult:
-        """Validate a single tool configuration through migration."""
-        result = ValidationResult(True, [], [], {})
-        
-        try:
-            # Create test JSON with just this tool
-            test_data = {
-                'export_path': 'test',
-                'tool_settings': {tool_name: tool_config}
-            }
-            
-            # Create temporary test file
-            test_file = os.path.join(self._test_data_dir or tempfile.gettempdir(), f"test_{tool_name.replace(' ', '_')}.json")
-            with open(test_file, 'w', encoding='utf-8') as f:
-                json.dump(test_data, f, indent=2)
-            
-            self._temp_files.append(test_file)
-            
-            # Test migration
-            migration_success = self.migration_manager.migrate_from_json(test_file, validate=False)
-            
-            if migration_success:
-                result.details['migration_success'] = True
-            else:
-                result.add_error(f"Migration failed for tool: {tool_name}")
-            
-            return result
-            
-        except Exception as e:
-            result.add_error(f"Tool configuration test failed for {tool_name}: {e}")
-            return result
-    
-    def _test_single_edge_case(self, case_name: str, test_data: Dict[str, Any]) -> ValidationResult:
-        """Test a single edge case scenario."""
-        result = ValidationResult(True, [], [], {})
-        
-        try:
-            # Create test file
-            test_file = os.path.join(self._test_data_dir or tempfile.gettempdir(), f"edge_case_{case_name}.json")
-            
-            with open(test_file, 'w', encoding='utf-8') as f:
-                json.dump(test_data, f, indent=2)
-            
-            self._temp_files.append(test_file)
-            
-            # Test migration (expect some to fail gracefully)
-            migration_success = self.migration_manager.migrate_from_json(test_file, validate=False)
-            
-            # For edge cases, we expect some to fail - that's okay
-            result.details['migration_attempted'] = True
-            result.details['migration_success'] = migration_success
-            result.details['case_data_size'] = len(json.dumps(test_data))
-            
-            return result
-            
-        except Exception as e:
-            # Edge cases are expected to sometimes cause exceptions
-            result.add_warning(f"Edge case {case_name} caused exception (expected): {e}")
-            result.details['exception_occurred'] = True
-            return result
-    
-    def _generate_large_test_data(self) -> Dict[str, Any]:
-        """Generate large test data for performance testing."""
-        large_data = {
-            'export_path': 'test',
-            'tool_settings': {}
-        }
-        
-        # Generate many tool configurations
-        for i in range(100):
-            large_data['tool_settings'][f'Test Tool {i}'] = {
-                'setting1': f'value_{i}',
-                'setting2': i * 10,
-                'setting3': [f'item_{j}' for j in range(10)],
-                'nested': {
-                    'deep': {
-                        'value': f'deep_value_{i}'
-                    }
-                }
-            }
-        
-        return large_data
-    
-    def _generate_unicode_test_data(self) -> Dict[str, Any]:
-        """Generate test data with Unicode content."""
-        return {
-            'export_path': 'тест',
-            'tool_settings': {
-                'Unicode Tool': {
-                    'name': '测试工具',
-                    'description': 'Тестовое описание',
-                    'emoji': '🚀🔧⚙️',
-                    'special_chars': '©®™€£¥'
-                }
-            }
-        }
-    
-    def _generate_encrypted_test_data(self) -> Dict[str, Any]:
-        """Generate test data with encrypted keys."""
-        return {
-            'export_path': 'test',
-            'tool_settings': {
-                'Encrypted Tool': {
-                    'API_KEY': 'ENC:dGVzdF9lbmNyeXB0ZWRfa2V5',
-                    'SECRET': 'ENC:YW5vdGhlcl9lbmNyeXB0ZWRfc2VjcmV0',
-                    'normal_setting': 'plain_value'
-                }
-            }
-        }
-    
-    def _generate_invalid_type_data(self) -> Dict[str, Any]:
-        """Generate test data with invalid types."""
-        return {
-            'export_path': 123,  # Should be string
-            'tool_settings': {
-                'Invalid Tool': {
-                    'setting': float('inf'),  # Invalid JSON value
-                    'another': complex(1, 2)  # Invalid JSON type
-                }
-            }
-        }
-    
-    def _generate_extra_fields_data(self) -> Dict[str, Any]:
-        """Generate test data with extra unknown fields."""
-        return {
-            'export_path': 'test',
-            'unknown_field': 'should_be_preserved',
-            'tool_settings': {
-                'Extra Fields Tool': {
-                    'standard_setting': 'value',
-                    'custom_field': 'custom_value',
-                    'metadata': {
-                        'version': '1.0',
-                        'author': 'test'
-                    }
-                }
-            },
-            'experimental_feature': True
-        }
-    
-    def _test_migration_performance(self, size_name: str, tool_count: int) -> ValidationResult:
-        """Test migration performance with specified data size."""
-        result = ValidationResult(True, [], [], {})
-        
-        try:
-            # Generate test data
-            test_data = {
-                'export_path': 'test',
-                'tool_settings': {}
-            }
-            
-            for i in range(tool_count):
-                test_data['tool_settings'][f'Tool_{i}'] = {
-                    'setting1': f'value_{i}',
-                    'setting2': i,
-                    'nested': {'deep': f'deep_{i}'}
-                }
-            
-            # Create test file
-            test_file = os.path.join(self._test_data_dir or tempfile.gettempdir(), f"perf_test_{size_name}.json")
-            
-            start_time = datetime.now()
-            with open(test_file, 'w', encoding='utf-8') as f:
-                json.dump(test_data, f)
-            write_time = (datetime.now() - start_time).total_seconds()
-            
-            self._temp_files.append(test_file)
-            
-            # Test migration performance
-            start_time = datetime.now()
-            migration_success = self.migration_manager.migrate_from_json(test_file, validate=False)
-            migration_time = (datetime.now() - start_time).total_seconds()
-            
-            result.details = {
-                'tool_count': tool_count,
-                'file_size': os.path.getsize(test_file),
-                'write_time': write_time,
-                'migration_time': migration_time,
-                'migration_success': migration_success,
-                'tools_per_second': tool_count / migration_time if migration_time > 0 else 0
-            }
-            
-            if not migration_success:
-                result.add_error(f"Performance test failed for {size_name} ({tool_count} tools)")
-            
-            return result
-            
-        except Exception as e:
-            result.add_error(f"Performance test failed for {size_name}: {e}")
-            return result
-    
-    def _validate_backup_integrity(self, original_file: str, backup_file: str) -> bool:
-        """Validate backup file integrity using checksums."""
-        try:
-            def get_file_hash(filepath: str) -> str:
-                with open(filepath, 'rb') as f:
-                    return hashlib.sha256(f.read()).hexdigest()
-            
-            original_hash = get_file_hash(original_file)
-            backup_hash = get_file_hash(backup_file)
-            
-            return original_hash == backup_hash
-            
-        except Exception as e:
-            self.logger.error(f"Backup integrity validation failed: {e}")
-            return False
-    
-    def _validate_rollback_integrity(self, backup_filepath: str) -> ValidationResult:
-        """Validate rollback operation integrity."""
-        result = ValidationResult(True, [], [], {})
-        
-        try:
-            # Determine original file path
-            original_path = backup_filepath.split('.backup_')[0]
-            
-            if os.path.exists(original_path):
-                integrity_valid = self._validate_backup_integrity(backup_filepath, original_path)
-                
-                if integrity_valid:
-                    result.details['rollback_integrity'] = True
-                else:
-                    result.add_error("Rollback integrity check failed")
-                    result.details['rollback_integrity'] = False
-            else:
-                result.add_warning("Original file not found for integrity check")
-            
-            return result
-            
-        except Exception as e:
-            result.add_error(f"Rollback integrity validation failed: {e}")
-            return result
-    
-    def _validate_database_types(self, conn: sqlite3.Connection) -> ValidationResult:
-        """Validate database data types and serialization."""
-        result = ValidationResult(True, [], [], {})
-        
-        try:
-            # Check data types in each table
-            tables_to_check = [
-                ('core_settings', ['key', 'value', 'data_type']),
-                ('tool_settings', ['tool_name', 'setting_path', 'setting_value', 'data_type']),
-                ('tab_content', ['tab_type', 'tab_index', 'content'])
-            ]
-            
-            for table_name, columns in tables_to_check:
-                cursor = conn.execute(f"SELECT * FROM {table_name} LIMIT 5")
-                rows = cursor.fetchall()
-                
-                result.details[f'{table_name}_sample_count'] = len(rows)
-                
-                # Check for data type consistency
-                if 'data_type' in columns:
-                    cursor = conn.execute(f"SELECT DISTINCT data_type FROM {table_name}")
-                    data_types = [row[0] for row in cursor.fetchall()]
-                    result.details[f'{table_name}_data_types'] = data_types
-            
-            return result
-            
-        except Exception as e:
-            result.add_error(f"Database type validation failed: {e}")
-            return result
-    
-    def _deep_compare_data(self, original: Dict[str, Any], migrated: Dict[str, Any]) -> ValidationResult:
-        """Perform deep comparison of original and migrated data."""
-        result = ValidationResult(True, [], [], {})
-        
-        try:
-            # Compare keys
-            original_keys = set(original.keys())
-            migrated_keys = set(migrated.keys())
-            
-            missing_keys = original_keys - migrated_keys
-            extra_keys = migrated_keys - original_keys
-            
-            if missing_keys:
-                result.add_error(f"Missing keys in migrated data: {missing_keys}")
-            
-            if extra_keys:
-                result.add_warning(f"Extra keys in migrated data: {extra_keys}")
-            
-            # Compare values for common keys
-            common_keys = original_keys & migrated_keys
-            value_differences = []
-            
-            for key in common_keys:
-                if not self._deep_equal(original[key], migrated[key]):
-                    value_differences.append(key)
-            
-            if value_differences:
-                result.add_error(f"Value differences found in keys: {value_differences}")
-            
-            result.details['comparison_summary'] = {
-                'total_original_keys': len(original_keys),
-                'total_migrated_keys': len(migrated_keys),
-                'common_keys': len(common_keys),
-                'missing_keys': len(missing_keys),
-                'extra_keys': len(extra_keys),
-                'value_differences': len(value_differences)
-            }
-            
-            return result
-            
-        except Exception as e:
-            result.add_error(f"Deep comparison failed: {e}")
-            return result
-    
-    def _deep_equal(self, obj1: Any, obj2: Any) -> bool:
-        """Deep equality comparison with type checking."""
-        if type(obj1) != type(obj2):
-            return False
-        
-        if isinstance(obj1, dict):
-            if set(obj1.keys()) != set(obj2.keys()):
-                return False
-            return all(self._deep_equal(obj1[k], obj2[k]) for k in obj1.keys())
-        
-        elif isinstance(obj1, list):
-            if len(obj1) != len(obj2):
-                return False
-            return all(self._deep_equal(obj1[i], obj2[i]) for i in range(len(obj1)))
-        
-        else:
-            return obj1 == obj2
-    
-    def _calculate_integrity_metrics(self, original: Dict[str, Any], migrated: Dict[str, Any]) -> Dict[str, Any]:
-        """Calculate data integrity metrics."""
-        try:
-            original_str = json.dumps(original, sort_keys=True)
-            migrated_str = json.dumps(migrated, sort_keys=True)
-            
-            # Calculate similarity metrics
-            original_size = len(original_str)
-            migrated_size = len(migrated_str)
-            
-            # Simple character-level similarity
-            min_len = min(original_size, migrated_size)
-            max_len = max(original_size, migrated_size)
-            
-            matching_chars = sum(1 for i in range(min_len) 
-                                if original_str[i] == migrated_str[i])
-            
-            similarity = matching_chars / max_len if max_len > 0 else 1.0
-            
-            return {
-                'original_size': original_size,
-                'migrated_size': migrated_size,
-                'size_difference': abs(original_size - migrated_size),
-                'character_similarity': similarity,
-                'exact_match': original_str == migrated_str
-            }
-            
-        except Exception as e:
-            return {
-                'error': str(e),
-                'exact_match': False
+"""
+Migration Validation System for Settings Database Migration
+
+This module provides comprehensive validation and testing capabilities for the
+migration system, including data integrity checks, edge case testing, and
+rollback procedures for all tool configurations.
+
+Designed to validate all 15+ tool configurations and complex data structures
+identified in the production codebase analysis.
+"""
+
+import json
+import sqlite3
+import os
+import shutil
+import logging
+import tempfile
+import hashlib
+from typing import Dict, List, Tuple, Any, Optional, Union, Set
+from datetime import datetime
+from pathlib import Path
+from dataclasses import dataclass
+
+from .migration_manager import MigrationManager
+from .database_connection_manager import DatabaseConnectionManager
+from .database_schema_manager import DatabaseSchemaManager
+
+
+@dataclass
+class ValidationResult:
+    """Result of a validation operation."""
+    success: bool
+    errors: List[str]
+    warnings: List[str]
+    details: Dict[str, Any]
+    
+    def add_error(self, error: str) -> None:
+        """Add an error to the result."""
+        self.errors.append(error)
+        self.success = False
+    
+    def add_warning(self, warning: str) -> None:
+        """Add a warning to the result."""
+        self.warnings.append(warning)
+    
+    def merge(self, other: 'ValidationResult') -> None:
+        """Merge another validation result into this one."""
+        self.errors.extend(other.errors)
+        self.warnings.extend(other.warnings)
+        self.details.update(other.details)
+        if not other.success:
+            self.success = False
+
+
+class MigrationValidator:
+    """
+    Comprehensive migration validation and testing system.
+    
+    Features:
+    - Data integrity validation for all tool configurations
+    - Edge case testing (corrupted JSON, missing fields, invalid data)
+    - Automatic backup creation and rollback procedures
+    - Performance testing for large settings files
+    - Comprehensive test suite for all 15+ tool types
+    """
+    
+    def __init__(self, migration_manager: MigrationManager):
+        """
+        Initialize the migration validator.
+        
+        Args:
+            migration_manager: MigrationManager instance to validate
+        """
+        self.migration_manager = migration_manager
+        self.logger = logging.getLogger(__name__)
+        
+        # Test configuration
+        self._test_data_dir = None
+        self._backup_dir = None
+        self._temp_files = []
+        
+        # Validation settings
+        self._strict_validation = True
+        self._validate_types = True
+        self._validate_structure = True
+        self._validate_content = True
+        
+        # Known tool configurations from production analysis
+        self._known_tools = {
+            'AI Tools', 'Base64 Encoder/Decoder', 'Case Tool', 'Cron Tool', 'Diff Viewer',
+            'Email Extraction Tool', 'Email Header Analyzer', 'Find & Replace Text', 
+            'Folder File Reporter', 'Generator Tools', 'HTML Extraction Tool', 
+            'JSON/XML Tool', 'Sorter Tools', 'Translator Tools', 'URL Parser', 
+            'URL and Link Extractor', 'Word Frequency Counter',
+            # AI Provider configurations (stored as separate tool settings)
+            'Google AI', 'Anthropic AI', 'OpenAI', 'AWS Bedrock', 'Cohere AI', 
+            'HuggingFace AI', 'Groq AI', 'OpenRouterAI', 'LM Studio'
+        }
+        
+        # Critical settings that must be preserved
+        self._critical_settings = {
+            'export_path', 'debug_level', 'selected_tool',
+            'active_input_tab', 'active_output_tab',
+            'input_tabs', 'output_tabs', 'tool_settings'
+        }
+    
+    def validate_complete_migration(self, json_filepath: str) -> ValidationResult:
+        """
+        Perform comprehensive validation of a complete migration cycle.
+        
+        Args:
+            json_filepath: Path to source JSON settings file
+            
+        Returns:
+            ValidationResult with comprehensive validation details
+        """
+        result = ValidationResult(True, [], [], {})
+        
+        try:
+            self.logger.info(f"Starting comprehensive migration validation: {json_filepath}")
+            
+            # Step 1: Validate source JSON file
+            source_validation = self._validate_source_json(json_filepath)
+            result.merge(source_validation)
+            
+            if not source_validation.success and self._strict_validation:
+                return result
+            
+            # Step 2: Create backup and test environment
+            backup_result = self._setup_test_environment(json_filepath)
+            result.merge(backup_result)
+            
+            # Step 3: Perform migration to database
+            migration_result = self._test_json_to_database_migration(json_filepath)
+            result.merge(migration_result)
+            
+            # Step 4: Validate database content
+            if migration_result.success:
+                db_validation = self._validate_database_content()
+                result.merge(db_validation)
+            
+            # Step 5: Test reverse migration
+            if migration_result.success:
+                reverse_result = self._test_database_to_json_migration()
+                result.merge(reverse_result)
+            
+            # Step 6: Validate round-trip accuracy
+            if reverse_result.success:
+                roundtrip_result = self._validate_roundtrip_accuracy(json_filepath)
+                result.merge(roundtrip_result)
+            
+            # Step 7: Test edge cases
+            edge_case_result = self._test_edge_cases()
+            result.merge(edge_case_result)
+            
+            # Step 8: Performance testing
+            performance_result = self._test_performance()
+            result.merge(performance_result)
+            
+            result.details['validation_summary'] = {
+                'total_tests': 8,
+                'passed_tests': sum(1 for r in [source_validation, backup_result, migration_result, 
+                                               db_validation, reverse_result, roundtrip_result,
+                                               edge_case_result, performance_result] if r.success),
+                'total_errors': len(result.errors),
+                'total_warnings': len(result.warnings)
+            }
+            
+            self.logger.info("Comprehensive migration validation completed")
+            return result
+            
+        except Exception as e:
+            result.add_error(f"Validation failed with exception: {e}")
+            self.logger.error(f"Migration validation error: {e}")
+            return result
+        
+        finally:
+            self._cleanup_test_environment()
+    
+    def validate_tool_configurations(self) -> ValidationResult:
+        """
+        Validate all known tool configurations for migration compatibility.
+        
+        Returns:
+            ValidationResult with tool-specific validation details
+        """
+        result = ValidationResult(True, [], [], {})
+        
+        try:
+            self.logger.info("Validating all tool configurations")
+            
+            # Create test data for each known tool
+            test_configs = self._generate_test_tool_configurations()
+            
+            for tool_name, tool_config in test_configs.items():
+                tool_result = self._validate_single_tool_configuration(tool_name, tool_config)
+                result.merge(tool_result)
+                
+                result.details[f'tool_{tool_name.replace(" ", "_")}'] = {
+                    'success': tool_result.success,
+                    'errors': tool_result.errors,
+                    'warnings': tool_result.warnings
+                }
+            
+            result.details['tool_validation_summary'] = {
+                'total_tools': len(test_configs),
+                'successful_tools': sum(1 for tool in result.details.values() 
+                                      if isinstance(tool, dict) and tool.get('success', False)),
+                'failed_tools': sum(1 for tool in result.details.values() 
+                                  if isinstance(tool, dict) and not tool.get('success', True))
+            }
+            
+            self.logger.info("Tool configuration validation completed")
+            return result
+            
+        except Exception as e:
+            result.add_error(f"Tool validation failed: {e}")
+            return result
+    
+    def test_edge_cases(self) -> ValidationResult:
+        """
+        Test migration with various edge cases and malformed data.
+        
+        Returns:
+            ValidationResult with edge case test results
+        """
+        result = ValidationResult(True, [], [], {})
+        
+        try:
+            self.logger.info("Testing migration edge cases")
+            
+            # Test cases for edge scenarios
+            edge_cases = [
+                ('empty_json', {}),
+                ('missing_tool_settings', {'export_path': 'test'}),
+                ('corrupted_nested_structure', {'tool_settings': {'invalid': None}}),
+                ('large_data_structure', self._generate_large_test_data()),
+                ('unicode_content', self._generate_unicode_test_data()),
+                ('encrypted_keys', self._generate_encrypted_test_data()),
+                ('invalid_types', self._generate_invalid_type_data()),
+                ('missing_tabs', {'tool_settings': {}}),
+                ('extra_fields', self._generate_extra_fields_data())
+            ]
+            
+            for case_name, test_data in edge_cases:
+                case_result = self._test_single_edge_case(case_name, test_data)
+                result.merge(case_result)
+                
+                result.details[f'edge_case_{case_name}'] = {
+                    'success': case_result.success,
+                    'errors': case_result.errors,
+                    'warnings': case_result.warnings
+                }
+            
+            result.details['edge_case_summary'] = {
+                'total_cases': len(edge_cases),
+                'passed_cases': sum(1 for case in result.details.values() 
+                                  if isinstance(case, dict) and case.get('success', False)),
+                'failed_cases': sum(1 for case in result.details.values() 
+                                  if isinstance(case, dict) and not case.get('success', True))
+            }
+            
+            self.logger.info("Edge case testing completed")
+            return result
+            
+        except Exception as e:
+            result.add_error(f"Edge case testing failed: {e}")
+            return result
+    
+    def create_automatic_backup(self, json_filepath: str) -> Tuple[bool, Optional[str]]:
+        """
+        Create automatic backup before migration with validation.
+        
+        Args:
+            json_filepath: Path to JSON file to backup
+            
+        Returns:
+            Tuple of (success, backup_path)
+        """
+        try:
+            if not os.path.exists(json_filepath):
+                self.logger.error(f"Source file not found: {json_filepath}")
+                return False, None
+            
+            # Generate backup path with timestamp
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            backup_path = f"{json_filepath}.backup_{timestamp}"
+            
+            # Create backup
+            shutil.copy2(json_filepath, backup_path)
+            
+            # Validate backup integrity
+            if self._validate_backup_integrity(json_filepath, backup_path):
+                self.logger.info(f"Automatic backup created: {backup_path}")
+                return True, backup_path
+            else:
+                self.logger.error("Backup integrity validation failed")
+                return False, None
+                
+        except Exception as e:
+            self.logger.error(f"Automatic backup failed: {e}")
+            return False, None
+    
+    def test_rollback_procedures(self, backup_filepath: str) -> ValidationResult:
+        """
+        Test rollback procedures for failed migrations.
+        
+        Args:
+            backup_filepath: Path to backup file for rollback testing
+            
+        Returns:
+            ValidationResult with rollback test results
+        """
+        result = ValidationResult(True, [], [], {})
+        
+        try:
+            self.logger.info(f"Testing rollback procedures: {backup_filepath}")
+            
+            if not os.path.exists(backup_filepath):
+                result.add_error(f"Backup file not found: {backup_filepath}")
+                return result
+            
+            # Test rollback functionality
+            rollback_success = self.migration_manager.rollback_migration(backup_filepath)
+            
+            if rollback_success:
+                result.details['rollback_test'] = {
+                    'success': True,
+                    'backup_file': backup_filepath,
+                    'rollback_time': datetime.now().isoformat()
+                }
+            else:
+                result.add_error("Rollback procedure failed")
+                result.details['rollback_test'] = {
+                    'success': False,
+                    'backup_file': backup_filepath,
+                    'error': 'Rollback operation failed'
+                }
+            
+            # Validate restored file integrity
+            if rollback_success:
+                integrity_result = self._validate_rollback_integrity(backup_filepath)
+                result.merge(integrity_result)
+            
+            self.logger.info("Rollback procedure testing completed")
+            return result
+            
+        except Exception as e:
+            result.add_error(f"Rollback testing failed: {e}")
+            return result
+    
+    # Private implementation methods
+    
+    def _validate_source_json(self, json_filepath: str) -> ValidationResult:
+        """Validate source JSON file structure and content."""
+        result = ValidationResult(True, [], [], {})
+        
+        try:
+            if not os.path.exists(json_filepath):
+                result.add_error(f"JSON file not found: {json_filepath}")
+                return result
+            
+            # Load and parse JSON
+            with open(json_filepath, 'r', encoding='utf-8') as f:
+                data = json.load(f)
+            
+            # Validate critical settings exist
+            for setting in self._critical_settings:
+                if setting not in data:
+                    if setting in ['input_tabs', 'output_tabs', 'tool_settings']:
+                        result.add_warning(f"Missing critical setting: {setting}")
+                    else:
+                        result.add_error(f"Missing critical setting: {setting}")
+            
+            # Validate tool settings structure
+            if 'tool_settings' in data:
+                tool_validation = self._validate_tool_settings_structure(data['tool_settings'])
+                result.merge(tool_validation)
+            
+            # Validate tab arrays
+            if 'input_tabs' in data:
+                tab_validation = self._validate_tab_arrays(data['input_tabs'], 'input_tabs')
+                result.merge(tab_validation)
+            
+            if 'output_tabs' in data:
+                tab_validation = self._validate_tab_arrays(data['output_tabs'], 'output_tabs')
+                result.merge(tab_validation)
+            
+            result.details['source_validation'] = {
+                'file_size': os.path.getsize(json_filepath),
+                'tool_count': len(data.get('tool_settings', {})),
+                'has_critical_settings': all(s in data for s in self._critical_settings)
+            }
+            
+            return result
+            
+        except json.JSONDecodeError as e:
+            result.add_error(f"Invalid JSON format: {e}")
+            return result
+        except Exception as e:
+            result.add_error(f"Source validation failed: {e}")
+            return result
+    
+    def _setup_test_environment(self, json_filepath: str) -> ValidationResult:
+        """Setup test environment with temporary directories and backups."""
+        result = ValidationResult(True, [], [], {})
+        
+        try:
+            # Create temporary test directory
+            self._test_data_dir = tempfile.mkdtemp(prefix="migration_test_")
+            self._backup_dir = os.path.join(self._test_data_dir, "backups")
+            os.makedirs(self._backup_dir, exist_ok=True)
+            
+            # Create backup
+            backup_success, backup_path = self.create_automatic_backup(json_filepath)
+            if backup_success:
+                result.details['backup_created'] = backup_path
+            else:
+                result.add_error("Failed to create test backup")
+            
+            result.details['test_environment'] = {
+                'test_dir': self._test_data_dir,
+                'backup_dir': self._backup_dir,
+                'setup_time': datetime.now().isoformat()
+            }
+            
+            return result
+            
+        except Exception as e:
+            result.add_error(f"Test environment setup failed: {e}")
+            return result
+    
+    def _test_json_to_database_migration(self, json_filepath: str) -> ValidationResult:
+        """Test JSON to database migration process."""
+        result = ValidationResult(True, [], [], {})
+        
+        try:
+            # Perform migration
+            migration_success = self.migration_manager.migrate_from_json(json_filepath, validate=True)
+            
+            if migration_success:
+                result.details['json_to_db_migration'] = {
+                    'success': True,
+                    'migration_time': datetime.now().isoformat()
+                }
+            else:
+                result.add_error("JSON to database migration failed")
+                result.details['json_to_db_migration'] = {
+                    'success': False,
+                    'error': 'Migration operation failed'
+                }
+            
+            return result
+            
+        except Exception as e:
+            result.add_error(f"JSON to database migration test failed: {e}")
+            return result
+    
+    def _validate_database_content(self) -> ValidationResult:
+        """Validate database content after migration."""
+        result = ValidationResult(True, [], [], {})
+        
+        try:
+            conn = self.migration_manager.connection_manager.get_connection()
+            
+            # Check all tables exist and have data
+            tables = ['core_settings', 'tool_settings', 'tab_content', 
+                     'performance_settings', 'font_settings', 'dialog_settings']
+            
+            for table in tables:
+                cursor = conn.execute(f"SELECT COUNT(*) FROM {table}")
+                count = cursor.fetchone()[0]
+                
+                result.details[f'{table}_count'] = count
+                
+                if table in ['core_settings', 'tool_settings'] and count == 0:
+                    result.add_warning(f"Table {table} is empty")
+            
+            # Validate data types and structure
+            type_validation = self._validate_database_types(conn)
+            result.merge(type_validation)
+            
+            return result
+            
+        except Exception as e:
+            result.add_error(f"Database content validation failed: {e}")
+            return result
+    
+    def _test_database_to_json_migration(self) -> ValidationResult:
+        """Test database to JSON migration process."""
+        result = ValidationResult(True, [], [], {})
+        
+        try:
+            # Create temporary JSON file for reverse migration
+            temp_json = os.path.join(self._test_data_dir, "reverse_migration.json")
+            
+            # Perform reverse migration
+            migration_success = self.migration_manager.migrate_to_json(temp_json, validate=True)
+            
+            if migration_success:
+                result.details['db_to_json_migration'] = {
+                    'success': True,
+                    'output_file': temp_json,
+                    'migration_time': datetime.now().isoformat()
+                }
+                self._temp_files.append(temp_json)
+            else:
+                result.add_error("Database to JSON migration failed")
+                result.details['db_to_json_migration'] = {
+                    'success': False,
+                    'error': 'Reverse migration operation failed'
+                }
+            
+            return result
+            
+        except Exception as e:
+            result.add_error(f"Database to JSON migration test failed: {e}")
+            return result
+    
+    def _validate_roundtrip_accuracy(self, original_json: str) -> ValidationResult:
+        """Validate round-trip migration accuracy."""
+        result = ValidationResult(True, [], [], {})
+        
+        try:
+            # Load original data
+            with open(original_json, 'r', encoding='utf-8') as f:
+                original_data = json.load(f)
+            
+            # Load migrated data
+            migrated_json = os.path.join(self._test_data_dir, "reverse_migration.json")
+            if not os.path.exists(migrated_json):
+                result.add_error("Migrated JSON file not found for comparison")
+                return result
+            
+            with open(migrated_json, 'r', encoding='utf-8') as f:
+                migrated_data = json.load(f)
+            
+            # Deep comparison
+            comparison_result = self._deep_compare_data(original_data, migrated_data)
+            result.merge(comparison_result)
+            
+            # Calculate data integrity metrics
+            integrity_metrics = self._calculate_integrity_metrics(original_data, migrated_data)
+            result.details['integrity_metrics'] = integrity_metrics
+            
+            return result
+            
+        except Exception as e:
+            result.add_error(f"Round-trip accuracy validation failed: {e}")
+            return result
+    
+    def _test_edge_cases(self) -> ValidationResult:
+        """Test various edge cases and error conditions."""
+        result = ValidationResult(True, [], [], {})
+        
+        # This is a placeholder - the actual implementation would be in test_edge_cases()
+        # which is already implemented above
+        edge_case_result = self.test_edge_cases()
+        result.merge(edge_case_result)
+        
+        return result
+    
+    def _test_performance(self) -> ValidationResult:
+        """Test migration performance with various data sizes."""
+        result = ValidationResult(True, [], [], {})
+        
+        try:
+            # Test with different data sizes
+            test_sizes = [
+                ('small', 10),      # 10 tools
+                ('medium', 50),     # 50 tools  
+                ('large', 100),     # 100 tools
+                ('xlarge', 500)     # 500 tools
+            ]
+            
+            for size_name, tool_count in test_sizes:
+                perf_result = self._test_migration_performance(size_name, tool_count)
+                result.merge(perf_result)
+                result.details[f'performance_{size_name}'] = perf_result.details
+            
+            return result
+            
+        except Exception as e:
+            result.add_error(f"Performance testing failed: {e}")
+            return result
+    
+    def _cleanup_test_environment(self) -> None:
+        """Clean up temporary test files and directories."""
+        try:
+            # Remove temporary files
+            for temp_file in self._temp_files:
+                if os.path.exists(temp_file):
+                    os.remove(temp_file)
+            
+            # Remove test directory
+            if self._test_data_dir and os.path.exists(self._test_data_dir):
+                shutil.rmtree(self._test_data_dir)
+            
+            self.logger.debug("Test environment cleaned up")
+            
+        except Exception as e:
+            self.logger.warning(f"Test cleanup failed: {e}")
+    
+    def _validate_tool_settings_structure(self, tool_settings: Dict[str, Any]) -> ValidationResult:
+        """Validate tool settings structure and known tools."""
+        result = ValidationResult(True, [], [], {})
+        
+        try:
+            # Check for known tools
+            found_tools = set(tool_settings.keys())
+            unknown_tools = found_tools - self._known_tools
+            
+            if unknown_tools:
+                result.add_warning(f"Unknown tools found: {unknown_tools}")
+            
+            # Validate each tool configuration
+            for tool_name, tool_config in tool_settings.items():
+                if not isinstance(tool_config, dict):
+                    result.add_error(f"Tool {tool_name} has invalid configuration type: {type(tool_config)}")
+                    continue
+                
+                # Tool-specific validation
+                tool_result = self._validate_specific_tool(tool_name, tool_config)
+                result.merge(tool_result)
+            
+            result.details['tool_structure_validation'] = {
+                'total_tools': len(tool_settings),
+                'known_tools': len(found_tools & self._known_tools),
+                'unknown_tools': len(unknown_tools)
+            }
+            
+            return result
+            
+        except Exception as e:
+            result.add_error(f"Tool settings validation failed: {e}")
+            return result
+    
+    def _validate_tab_arrays(self, tab_data: List[str], tab_type: str) -> ValidationResult:
+        """Validate tab array structure and content."""
+        result = ValidationResult(True, [], [], {})
+        
+        try:
+            if not isinstance(tab_data, list):
+                result.add_error(f"{tab_type} is not a list: {type(tab_data)}")
+                return result
+            
+            # Check tab count (should be 7)
+            if len(tab_data) != 7:
+                result.add_warning(f"{tab_type} has {len(tab_data)} tabs, expected 7")
+            
+            # Check tab content types
+            for i, content in enumerate(tab_data):
+                if not isinstance(content, str):
+                    result.add_error(f"{tab_type}[{i}] is not a string: {type(content)}")
+            
+            result.details[f'{tab_type}_validation'] = {
+                'tab_count': len(tab_data),
+                'non_empty_tabs': sum(1 for tab in tab_data if tab.strip()),
+                'total_content_length': sum(len(tab) for tab in tab_data)
+            }
+            
+            return result
+            
+        except Exception as e:
+            result.add_error(f"Tab array validation failed: {e}")
+            return result
+    
+    def _validate_specific_tool(self, tool_name: str, tool_config: Dict[str, Any]) -> ValidationResult:
+        """Validate specific tool configuration based on known patterns."""
+        result = ValidationResult(True, [], [], {})
+        
+        try:
+            # AI tools validation
+            if any(ai_name in tool_name for ai_name in ['AI', 'Google', 'Anthropic', 'OpenAI', 'Cohere', 'HuggingFace', 'Groq', 'OpenRouter', 'AWS Bedrock', 'LM Studio']):
+                ai_result = self._validate_ai_tool_config(tool_name, tool_config)
+                result.merge(ai_result)
+            
+            # cURL tool validation
+            elif tool_name == 'cURL Tool':
+                curl_result = self._validate_curl_tool_config(tool_config)
+                result.merge(curl_result)
+            
+            # Generator tools validation
+            elif tool_name == 'Generator Tools':
+                gen_result = self._validate_generator_tools_config(tool_config)
+                result.merge(gen_result)
+            
+            # Other tool validations can be added here
+            
+            return result
+            
+        except Exception as e:
+            result.add_error(f"Specific tool validation failed for {tool_name}: {e}")
+            return result
+    
+    def _validate_ai_tool_config(self, tool_name: str, config: Dict[str, Any]) -> ValidationResult:
+        """Validate AI tool configuration."""
+        result = ValidationResult(True, [], [], {})
+        
+        # Check for required AI tool fields
+        required_fields = ['API_KEY', 'MODEL']
+        for field in required_fields:
+            if field not in config:
+                result.add_error(f"AI tool {tool_name} missing required field: {field}")
+        
+        # Check for encrypted API keys
+        if 'API_KEY' in config and config['API_KEY'].startswith('ENC:'):
+            result.details[f'{tool_name}_encrypted'] = True
+        
+        # Check model list
+        if 'MODELS_LIST' in config and isinstance(config['MODELS_LIST'], list):
+            result.details[f'{tool_name}_model_count'] = len(config['MODELS_LIST'])
+        
+        return result
+    
+    def _validate_curl_tool_config(self, config: Dict[str, Any]) -> ValidationResult:
+        """Validate cURL tool configuration."""
+        result = ValidationResult(True, [], [], {})
+        
+        # Check for history array
+        if 'history' in config:
+            if isinstance(config['history'], list):
+                result.details['curl_history_count'] = len(config['history'])
+                
+                # Validate history entries
+                for i, entry in enumerate(config['history']):
+                    if not isinstance(entry, dict):
+                        result.add_error(f"cURL history entry {i} is not a dict")
+                        continue
+                    
+                    required_history_fields = ['timestamp', 'method', 'url', 'status_code']
+                    for field in required_history_fields:
+                        if field not in entry:
+                            result.add_warning(f"cURL history entry {i} missing field: {field}")
+            else:
+                result.add_error("cURL history is not a list")
+        
+        return result
+    
+    def _validate_generator_tools_config(self, config: Dict[str, Any]) -> ValidationResult:
+        """Validate Generator Tools nested configuration."""
+        result = ValidationResult(True, [], [], {})
+        
+        # Check for nested tool configurations
+        expected_generators = [
+            'Strong Password Generator', 'Repeating Text Generator',
+            'Lorem Ipsum Generator', 'UUID/GUID Generator'
+        ]
+        
+        for generator in expected_generators:
+            if generator in config:
+                if not isinstance(config[generator], dict):
+                    result.add_error(f"Generator {generator} config is not a dict")
+            else:
+                result.add_warning(f"Generator {generator} not found in config")
+        
+        result.details['generator_tools_count'] = len(config)
+        
+        return result
+    
+    def _generate_test_tool_configurations(self) -> Dict[str, Dict[str, Any]]:
+        """Generate test configurations for all known tools."""
+        return {
+            'Test AI Tool': {
+                'API_KEY': 'test_key',
+                'MODEL': 'test_model',
+                'MODELS_LIST': ['model1', 'model2'],
+                'temperature': 0.7
+            },
+            'Test cURL Tool': {
+                'default_timeout': 30,
+                'history': [
+                    {
+                        'timestamp': '2025-01-01T00:00:00',
+                        'method': 'GET',
+                        'url': 'https://test.com',
+                        'status_code': 200
+                    }
+                ]
+            },
+            'Test Generator Tools': {
+                'Password Generator': {
+                    'length': 12,
+                    'symbols': True
+                }
+            }
+        }
+    
+    def _validate_single_tool_configuration(self, tool_name: str, tool_config: Dict[str, Any]) -> ValidationResult:
+        """Validate a single tool configuration through migration."""
+        result = ValidationResult(True, [], [], {})
+        
+        try:
+            # Create test JSON with just this tool
+            test_data = {
+                'export_path': 'test',
+                'tool_settings': {tool_name: tool_config}
+            }
+            
+            # Create temporary test file
+            test_file = os.path.join(self._test_data_dir or tempfile.gettempdir(), f"test_{tool_name.replace(' ', '_')}.json")
+            with open(test_file, 'w', encoding='utf-8') as f:
+                json.dump(test_data, f, indent=2)
+            
+            self._temp_files.append(test_file)
+            
+            # Test migration
+            migration_success = self.migration_manager.migrate_from_json(test_file, validate=False)
+            
+            if migration_success:
+                result.details['migration_success'] = True
+            else:
+                result.add_error(f"Migration failed for tool: {tool_name}")
+            
+            return result
+            
+        except Exception as e:
+            result.add_error(f"Tool configuration test failed for {tool_name}: {e}")
+            return result
+    
+    def _test_single_edge_case(self, case_name: str, test_data: Dict[str, Any]) -> ValidationResult:
+        """Test a single edge case scenario."""
+        result = ValidationResult(True, [], [], {})
+        
+        try:
+            # Create test file
+            test_file = os.path.join(self._test_data_dir or tempfile.gettempdir(), f"edge_case_{case_name}.json")
+            
+            with open(test_file, 'w', encoding='utf-8') as f:
+                json.dump(test_data, f, indent=2)
+            
+            self._temp_files.append(test_file)
+            
+            # Test migration (expect some to fail gracefully)
+            migration_success = self.migration_manager.migrate_from_json(test_file, validate=False)
+            
+            # For edge cases, we expect some to fail - that's okay
+            result.details['migration_attempted'] = True
+            result.details['migration_success'] = migration_success
+            result.details['case_data_size'] = len(json.dumps(test_data))
+            
+            return result
+            
+        except Exception as e:
+            # Edge cases are expected to sometimes cause exceptions
+            result.add_warning(f"Edge case {case_name} caused exception (expected): {e}")
+            result.details['exception_occurred'] = True
+            return result
+    
+    def _generate_large_test_data(self) -> Dict[str, Any]:
+        """Generate large test data for performance testing."""
+        large_data = {
+            'export_path': 'test',
+            'tool_settings': {}
+        }
+        
+        # Generate many tool configurations
+        for i in range(100):
+            large_data['tool_settings'][f'Test Tool {i}'] = {
+                'setting1': f'value_{i}',
+                'setting2': i * 10,
+                'setting3': [f'item_{j}' for j in range(10)],
+                'nested': {
+                    'deep': {
+                        'value': f'deep_value_{i}'
+                    }
+                }
+            }
+        
+        return large_data
+    
+    def _generate_unicode_test_data(self) -> Dict[str, Any]:
+        """Generate test data with Unicode content."""
+        return {
+            'export_path': 'тест',
+            'tool_settings': {
+                'Unicode Tool': {
+                    'name': '测试工具',
+                    'description': 'Тестовое описание',
+                    'emoji': '🚀🔧⚙️',
+                    'special_chars': '©®™€£¥'
+                }
+            }
+        }
+    
+    def _generate_encrypted_test_data(self) -> Dict[str, Any]:
+        """Generate test data with encrypted keys."""
+        return {
+            'export_path': 'test',
+            'tool_settings': {
+                'Encrypted Tool': {
+                    'API_KEY': 'ENC:dGVzdF9lbmNyeXB0ZWRfa2V5',
+                    'SECRET': 'ENC:YW5vdGhlcl9lbmNyeXB0ZWRfc2VjcmV0',
+                    'normal_setting': 'plain_value'
+                }
+            }
+        }
+    
+    def _generate_invalid_type_data(self) -> Dict[str, Any]:
+        """Generate test data with invalid types."""
+        return {
+            'export_path': 123,  # Should be string
+            'tool_settings': {
+                'Invalid Tool': {
+                    'setting': float('inf'),  # Invalid JSON value
+                    'another': complex(1, 2)  # Invalid JSON type
+                }
+            }
+        }
+    
+    def _generate_extra_fields_data(self) -> Dict[str, Any]:
+        """Generate test data with extra unknown fields."""
+        return {
+            'export_path': 'test',
+            'unknown_field': 'should_be_preserved',
+            'tool_settings': {
+                'Extra Fields Tool': {
+                    'standard_setting': 'value',
+                    'custom_field': 'custom_value',
+                    'metadata': {
+                        'version': '1.0',
+                        'author': 'test'
+                    }
+                }
+            },
+            'experimental_feature': True
+        }
+    
+    def _test_migration_performance(self, size_name: str, tool_count: int) -> ValidationResult:
+        """Test migration performance with specified data size."""
+        result = ValidationResult(True, [], [], {})
+        
+        try:
+            # Generate test data
+            test_data = {
+                'export_path': 'test',
+                'tool_settings': {}
+            }
+            
+            for i in range(tool_count):
+                test_data['tool_settings'][f'Tool_{i}'] = {
+                    'setting1': f'value_{i}',
+                    'setting2': i,
+                    'nested': {'deep': f'deep_{i}'}
+                }
+            
+            # Create test file
+            test_file = os.path.join(self._test_data_dir or tempfile.gettempdir(), f"perf_test_{size_name}.json")
+            
+            start_time = datetime.now()
+            with open(test_file, 'w', encoding='utf-8') as f:
+                json.dump(test_data, f)
+            write_time = (datetime.now() - start_time).total_seconds()
+            
+            self._temp_files.append(test_file)
+            
+            # Test migration performance
+            start_time = datetime.now()
+            migration_success = self.migration_manager.migrate_from_json(test_file, validate=False)
+            migration_time = (datetime.now() - start_time).total_seconds()
+            
+            result.details = {
+                'tool_count': tool_count,
+                'file_size': os.path.getsize(test_file),
+                'write_time': write_time,
+                'migration_time': migration_time,
+                'migration_success': migration_success,
+                'tools_per_second': tool_count / migration_time if migration_time > 0 else 0
+            }
+            
+            if not migration_success:
+                result.add_error(f"Performance test failed for {size_name} ({tool_count} tools)")
+            
+            return result
+            
+        except Exception as e:
+            result.add_error(f"Performance test failed for {size_name}: {e}")
+            return result
+    
+    def _validate_backup_integrity(self, original_file: str, backup_file: str) -> bool:
+        """Validate backup file integrity using checksums."""
+        try:
+            def get_file_hash(filepath: str) -> str:
+                with open(filepath, 'rb') as f:
+                    return hashlib.sha256(f.read()).hexdigest()
+            
+            original_hash = get_file_hash(original_file)
+            backup_hash = get_file_hash(backup_file)
+            
+            return original_hash == backup_hash
+            
+        except Exception as e:
+            self.logger.error(f"Backup integrity validation failed: {e}")
+            return False
+    
+    def _validate_rollback_integrity(self, backup_filepath: str) -> ValidationResult:
+        """Validate rollback operation integrity."""
+        result = ValidationResult(True, [], [], {})
+        
+        try:
+            # Determine original file path
+            original_path = backup_filepath.split('.backup_')[0]
+            
+            if os.path.exists(original_path):
+                integrity_valid = self._validate_backup_integrity(backup_filepath, original_path)
+                
+                if integrity_valid:
+                    result.details['rollback_integrity'] = True
+                else:
+                    result.add_error("Rollback integrity check failed")
+                    result.details['rollback_integrity'] = False
+            else:
+                result.add_warning("Original file not found for integrity check")
+            
+            return result
+            
+        except Exception as e:
+            result.add_error(f"Rollback integrity validation failed: {e}")
+            return result
+    
+    def _validate_database_types(self, conn: sqlite3.Connection) -> ValidationResult:
+        """Validate database data types and serialization."""
+        result = ValidationResult(True, [], [], {})
+        
+        try:
+            # Check data types in each table
+            tables_to_check = [
+                ('core_settings', ['key', 'value', 'data_type']),
+                ('tool_settings', ['tool_name', 'setting_path', 'setting_value', 'data_type']),
+                ('tab_content', ['tab_type', 'tab_index', 'content'])
+            ]
+            
+            for table_name, columns in tables_to_check:
+                cursor = conn.execute(f"SELECT * FROM {table_name} LIMIT 5")
+                rows = cursor.fetchall()
+                
+                result.details[f'{table_name}_sample_count'] = len(rows)
+                
+                # Check for data type consistency
+                if 'data_type' in columns:
+                    cursor = conn.execute(f"SELECT DISTINCT data_type FROM {table_name}")
+                    data_types = [row[0] for row in cursor.fetchall()]
+                    result.details[f'{table_name}_data_types'] = data_types
+            
+            return result
+            
+        except Exception as e:
+            result.add_error(f"Database type validation failed: {e}")
+            return result
+    
+    def _deep_compare_data(self, original: Dict[str, Any], migrated: Dict[str, Any]) -> ValidationResult:
+        """Perform deep comparison of original and migrated data."""
+        result = ValidationResult(True, [], [], {})
+        
+        try:
+            # Compare keys
+            original_keys = set(original.keys())
+            migrated_keys = set(migrated.keys())
+            
+            missing_keys = original_keys - migrated_keys
+            extra_keys = migrated_keys - original_keys
+            
+            if missing_keys:
+                result.add_error(f"Missing keys in migrated data: {missing_keys}")
+            
+            if extra_keys:
+                result.add_warning(f"Extra keys in migrated data: {extra_keys}")
+            
+            # Compare values for common keys
+            common_keys = original_keys & migrated_keys
+            value_differences = []
+            
+            for key in common_keys:
+                if not self._deep_equal(original[key], migrated[key]):
+                    value_differences.append(key)
+            
+            if value_differences:
+                result.add_error(f"Value differences found in keys: {value_differences}")
+            
+            result.details['comparison_summary'] = {
+                'total_original_keys': len(original_keys),
+                'total_migrated_keys': len(migrated_keys),
+                'common_keys': len(common_keys),
+                'missing_keys': len(missing_keys),
+                'extra_keys': len(extra_keys),
+                'value_differences': len(value_differences)
+            }
+            
+            return result
+            
+        except Exception as e:
+            result.add_error(f"Deep comparison failed: {e}")
+            return result
+    
+    def _deep_equal(self, obj1: Any, obj2: Any) -> bool:
+        """Deep equality comparison with type checking."""
+        if type(obj1) != type(obj2):
+            return False
+        
+        if isinstance(obj1, dict):
+            if set(obj1.keys()) != set(obj2.keys()):
+                return False
+            return all(self._deep_equal(obj1[k], obj2[k]) for k in obj1.keys())
+        
+        elif isinstance(obj1, list):
+            if len(obj1) != len(obj2):
+                return False
+            return all(self._deep_equal(obj1[i], obj2[i]) for i in range(len(obj1)))
+        
+        else:
+            return obj1 == obj2
+    
+    def _calculate_integrity_metrics(self, original: Dict[str, Any], migrated: Dict[str, Any]) -> Dict[str, Any]:
+        """Calculate data integrity metrics."""
+        try:
+            original_str = json.dumps(original, sort_keys=True)
+            migrated_str = json.dumps(migrated, sort_keys=True)
+            
+            # Calculate similarity metrics
+            original_size = len(original_str)
+            migrated_size = len(migrated_str)
+            
+            # Simple character-level similarity
+            min_len = min(original_size, migrated_size)
+            max_len = max(original_size, migrated_size)
+            
+            matching_chars = sum(1 for i in range(min_len) 
+                                if original_str[i] == migrated_str[i])
+            
+            similarity = matching_chars / max_len if max_len > 0 else 1.0
+            
+            return {
+                'original_size': original_size,
+                'migrated_size': migrated_size,
+                'size_difference': abs(original_size - migrated_size),
+                'character_similarity': similarity,
+                'exact_match': original_str == migrated_str
+            }
+            
+        except Exception as e:
+            return {
+                'error': str(e),
+                'exact_match': False
             }