Readur/src/ocr_tests.rs

#[cfg(test)]
mod tests {
    use super::super::*;
    use crate::ocr_error::{OcrError, OcrDiagnostics, CpuFeatures};
    use crate::ocr_health::OcrHealthChecker;
    use crate::ocr_enhanced::EnhancedOcrService;
    use std::env;
    use tempfile::TempDir;
    use std::fs;

    #[test]
    fn test_ocr_error_types() {
        // Test error creation and properties
        let err = OcrError::TesseractNotInstalled;
        assert_eq!(err.error_code(), "OCR_NOT_INSTALLED");
        assert!(!err.is_recoverable());
        assert!(err.is_configuration_error());

        let err = OcrError::InsufficientMemory { required: 1000, available: 500 };
        assert_eq!(err.error_code(), "OCR_OUT_OF_MEMORY");
        assert!(err.is_recoverable());
        assert!(!err.is_configuration_error());

        let err = OcrError::LanguageDataNotFound { lang: "deu".to_string() };
        assert!(err.to_string().contains("deu"));
        assert!(err.is_configuration_error());
    }

    #[test]
    fn test_cpu_features_display() {
        let features = CpuFeatures {
            sse2: true,
            sse3: true,
            sse4_1: false,
            sse4_2: false,
            avx: false,
            avx2: false,
        };
        
        let diag = OcrDiagnostics {
            tesseract_version: Some("4.1.1".to_string()),
            available_languages: vec!["eng".to_string(), "fra".to_string()],
            tessdata_path: Some("/usr/share/tessdata".to_string()),
            cpu_features: features,
            memory_available_mb: 8192,
            temp_space_available_mb: 50000,
        };
        
        let display = format!("{}", diag);
        assert!(display.contains("Tesseract Version: 4.1.1"));
        assert!(display.contains("SSE2: true"));
        assert!(display.contains("Available Languages: eng, fra"));
    }

    #[test]
    fn test_health_checker_cpu_validation() {
        let checker = OcrHealthChecker::new();
        let features = checker.check_cpu_features();
        
        // On x86/x64, we should at least detect the presence of CPU features
        #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
        {
            // Modern CPUs should have at least SSE2
            // Note: This might fail on very old hardware
            if std::env::var("CI").is_err() {
                // Only check in non-CI environments
                let _ = checker.validate_cpu_requirements();
            }
        }
    }

    #[test]
    fn test_memory_estimation() {
        let checker = OcrHealthChecker::new();
        
        // Test memory estimation for different image sizes
        let small_image = checker.estimate_memory_requirement(640, 480);
        let medium_image = checker.estimate_memory_requirement(1920, 1080);
        let large_image = checker.estimate_memory_requirement(4096, 4096);
        
        // Small image should need less memory than large
        assert!(small_image < medium_image);
        assert!(medium_image < large_image);
        
        // Base overhead is 100MB
        assert!(small_image >= 100);
    }

    #[test]
    fn test_temp_space_check() {
        let checker = OcrHealthChecker::new();
        let space = checker.check_temp_space();
        
        // Should return some positive value
        assert!(space > 0);
    }

    #[test]
    fn test_tessdata_path_detection() {
        let checker = OcrHealthChecker::new();
        
        // Set a custom TESSDATA_PREFIX for testing
        let temp_dir = TempDir::new().unwrap();
        env::set_var("TESSDATA_PREFIX", temp_dir.path());
        
        match checker.get_tessdata_path() {
            Ok(path) => assert_eq!(path, temp_dir.path().to_string_lossy()),
            Err(e) => {
                // Expected if the temp directory doesn't exist
                match e {
                    OcrError::TessdataPathInvalid { .. } => (),
                    _ => panic!("Unexpected error type"),
                }
            }
        }
        
        env::remove_var("TESSDATA_PREFIX");
    }

    #[test]
    fn test_language_detection() {
        let checker = OcrHealthChecker::new();
        
        // Create a mock tessdata directory
        let temp_dir = TempDir::new().unwrap();
        let tessdata_path = temp_dir.path().join("tessdata");
        fs::create_dir(&tessdata_path).unwrap();
        
        // Create mock language files
        fs::write(tessdata_path.join("eng.traineddata"), b"mock").unwrap();
        fs::write(tessdata_path.join("fra.traineddata"), b"mock").unwrap();
        fs::write(tessdata_path.join("deu.traineddata"), b"mock").unwrap();
        
        env::set_var("TESSDATA_PREFIX", &tessdata_path);
        
        let languages = checker.get_available_languages();
        assert!(languages.contains(&"eng".to_string()));
        assert!(languages.contains(&"fra".to_string()));
        assert!(languages.contains(&"deu".to_string()));
        assert_eq!(languages.len(), 3);
        
        // Test language validation
        assert!(checker.check_language_data("eng").is_ok());
        assert!(checker.check_language_data("jpn").is_err());
        
        env::remove_var("TESSDATA_PREFIX");
    }

    #[tokio::test]
    async fn test_enhanced_ocr_timeout() {
        let service = EnhancedOcrService::new()
            .with_timeout(1); // 1 second timeout
        
        // This should timeout since no actual file exists
        let result = service.extract_text_with_validation("/nonexistent/file.png", "eng").await;
        assert!(result.is_err());
    }

    #[tokio::test]
    async fn test_enhanced_ocr_image_validation() {
        let service = EnhancedOcrService::new()
            .with_limits(100, 100); // Very small limit
        
        // Create a mock large image path
        let result = service.extract_text_with_validation("/path/to/large/image.png", "eng").await;
        assert!(result.is_err());
    }

    #[test]
    fn test_error_recovery_classification() {
        // Test which errors are considered recoverable
        let recoverable_errors = vec![
            OcrError::InsufficientMemory { required: 1000, available: 500 },
            OcrError::OcrTimeout { seconds: 30 },
            OcrError::LowConfidence { score: 40.0, threshold: 60.0 },
        ];
        
        for err in recoverable_errors {
            assert!(err.is_recoverable(), "Error {:?} should be recoverable", err);
        }
        
        let non_recoverable_errors = vec![
            OcrError::TesseractNotInstalled,
            OcrError::LanguageDataNotFound { lang: "eng".to_string() },
            OcrError::MissingCpuInstruction { instruction: "SSE2".to_string() },
            OcrError::PermissionDenied { path: "/test".to_string() },
        ];
        
        for err in non_recoverable_errors {
            assert!(!err.is_recoverable(), "Error {:?} should not be recoverable", err);
        }
    }

    #[test]
    fn test_image_size_validation() {
        let checker = OcrHealthChecker::new();
        
        // Small image should pass
        assert!(checker.validate_memory_for_image(640, 480).is_ok());
        
        // Test with a ridiculously large image that would require more memory than any system has
        // 100,000 x 100,000 pixels = 10 billion pixels * 4 bytes * 3 buffers = ~120GB
        let result = checker.validate_memory_for_image(100000, 100000);
        assert!(result.is_err());
        
        if let Err(OcrError::InsufficientMemory { required, available }) = result {
            assert!(required > available);
        } else {
            panic!("Expected InsufficientMemory error, got: {:?}", result);
        }
    }
}