kreuzberg 4.0.0.rc1

data/vendor/kreuzberg/tests/registry_integration_tests.rs

@@ -0,0 +1,607 @@
+//! Plugin registry integration tests.
+//!
+//! Tests the core registry APIs for all plugin types:
+//! - Validator registration/unregistration
+//! - Extractor registration/unregistration
+//! - Registry clearing and listing
+//! - Error handling and edge cases
+
+use async_trait::async_trait;
+use kreuzberg::core::config::ExtractionConfig;
+use kreuzberg::plugins::registry::{DocumentExtractorRegistry, ValidatorRegistry};
+use kreuzberg::plugins::{DocumentExtractor, Plugin, Validator};
+use kreuzberg::types::{ExtractionResult, Metadata};
+use kreuzberg::{KreuzbergError, Result};
+use std::path::Path;
+use std::sync::Arc;
+
+// ===== Mock Validators =====
+
+struct MockValidator {
+    name: String,
+    should_fail: bool,
+}
+
+impl Plugin for MockValidator {
+    fn name(&self) -> &str {
+        &self.name
+    }
+
+    fn version(&self) -> String {
+        "1.0.0".to_string()
+    }
+
+    fn initialize(&self) -> Result<()> {
+        Ok(())
+    }
+
+    fn shutdown(&self) -> Result<()> {
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl Validator for MockValidator {
+    async fn validate(&self, _result: &ExtractionResult, _config: &ExtractionConfig) -> Result<()> {
+        if self.should_fail {
+            Err(KreuzbergError::validation("Mock validation failed"))
+        } else {
+            Ok(())
+        }
+    }
+
+    fn priority(&self) -> i32 {
+        50
+    }
+}
+
+struct FailingInitValidator {
+    name: String,
+}
+
+impl Plugin for FailingInitValidator {
+    fn name(&self) -> &str {
+        &self.name
+    }
+
+    fn version(&self) -> String {
+        "1.0.0".to_string()
+    }
+
+    fn initialize(&self) -> Result<()> {
+        Err(KreuzbergError::Plugin {
+            message: "Initialization failed".to_string(),
+            plugin_name: self.name.clone(),
+        })
+    }
+
+    fn shutdown(&self) -> Result<()> {
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl Validator for FailingInitValidator {
+    async fn validate(&self, _result: &ExtractionResult, _config: &ExtractionConfig) -> Result<()> {
+        Ok(())
+    }
+}
+
+// ===== Mock Extractors =====
+
+struct MockExtractor {
+    name: String,
+    mime_types: Vec<&'static str>,
+    priority: i32,
+}
+
+impl Plugin for MockExtractor {
+    fn name(&self) -> &str {
+        &self.name
+    }
+
+    fn version(&self) -> String {
+        "1.0.0".to_string()
+    }
+
+    fn initialize(&self) -> Result<()> {
+        Ok(())
+    }
+
+    fn shutdown(&self) -> Result<()> {
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl DocumentExtractor for MockExtractor {
+    async fn extract_bytes(
+        &self,
+        content: &[u8],
+        mime_type: &str,
+        _config: &ExtractionConfig,
+    ) -> Result<ExtractionResult> {
+        Ok(ExtractionResult {
+            content: format!("Extracted by {}: {}", self.name, String::from_utf8_lossy(content)),
+            mime_type: mime_type.to_string(),
+            metadata: Metadata::default(),
+            tables: vec![],
+            detected_languages: None,
+            chunks: None,
+            images: None,
+        })
+    }
+
+    async fn extract_file(&self, path: &Path, mime_type: &str, config: &ExtractionConfig) -> Result<ExtractionResult> {
+        let content = std::fs::read(path)?;
+        self.extract_bytes(&content, mime_type, config).await
+    }
+
+    fn supported_mime_types(&self) -> &[&str] {
+        &self.mime_types
+    }
+
+    fn priority(&self) -> i32 {
+        self.priority
+    }
+}
+
+// ===== Validator Registry Tests =====
+
+/// Test validator registration and listing.
+#[test]
+fn test_validator_registration_succeeds() {
+    let mut registry = ValidatorRegistry::new();
+
+    let validator = Arc::new(MockValidator {
+        name: "test-validator".to_string(),
+        should_fail: false,
+    });
+
+    let result = registry.register(validator);
+    assert!(result.is_ok(), "Validator registration should succeed");
+
+    let list = registry.list();
+    assert_eq!(list.len(), 1, "Should have one validator");
+    assert!(
+        list.contains(&"test-validator".to_string()),
+        "Should contain registered validator"
+    );
+}
+
+/// Test registering multiple validators.
+#[test]
+fn test_register_multiple_validators_succeeds() {
+    let mut registry = ValidatorRegistry::new();
+
+    let v1 = Arc::new(MockValidator {
+        name: "validator-1".to_string(),
+        should_fail: false,
+    });
+    let v2 = Arc::new(MockValidator {
+        name: "validator-2".to_string(),
+        should_fail: false,
+    });
+    let v3 = Arc::new(MockValidator {
+        name: "validator-3".to_string(),
+        should_fail: true,
+    });
+
+    registry.register(v1).unwrap();
+    registry.register(v2).unwrap();
+    registry.register(v3).unwrap();
+
+    let list = registry.list();
+    assert_eq!(list.len(), 3, "Should have three validators");
+    assert!(list.contains(&"validator-1".to_string()));
+    assert!(list.contains(&"validator-2".to_string()));
+    assert!(list.contains(&"validator-3".to_string()));
+}
+
+/// Test validator unregistration.
+#[test]
+fn test_validator_unregistration_succeeds() {
+    let mut registry = ValidatorRegistry::new();
+
+    let validator = Arc::new(MockValidator {
+        name: "temp-validator".to_string(),
+        should_fail: false,
+    });
+
+    registry.register(validator).unwrap();
+    assert_eq!(registry.list().len(), 1);
+
+    let result = registry.remove("temp-validator");
+    assert!(result.is_ok(), "Unregistration should succeed");
+    assert_eq!(registry.list().len(), 0, "Registry should be empty after removal");
+}
+
+/// Test unregistering non-existent validator.
+#[test]
+fn test_unregister_nonexistent_validator_succeeds() {
+    let mut registry = ValidatorRegistry::new();
+
+    let result = registry.remove("nonexistent-validator");
+    assert!(result.is_ok(), "Removing non-existent validator should succeed (no-op)");
+}
+
+/// Test validator registration with empty name fails.
+#[test]
+fn test_validator_registration_with_empty_name_fails() {
+    let mut registry = ValidatorRegistry::new();
+
+    let validator = Arc::new(MockValidator {
+        name: "".to_string(),
+        should_fail: false,
+    });
+
+    let result = registry.register(validator);
+    assert!(result.is_err(), "Registration with empty name should fail");
+
+    match result {
+        Err(KreuzbergError::Validation { message, .. }) => {
+            assert!(message.contains("empty"), "Error should mention empty name");
+        }
+        _ => panic!("Expected Validation error"),
+    }
+}
+
+/// Test validator registration with whitespace in name fails.
+#[test]
+fn test_validator_registration_with_whitespace_fails() {
+    let mut registry = ValidatorRegistry::new();
+
+    let validator = Arc::new(MockValidator {
+        name: "validator with spaces".to_string(),
+        should_fail: false,
+    });
+
+    let result = registry.register(validator);
+    assert!(result.is_err(), "Registration with whitespace should fail");
+
+    match result {
+        Err(KreuzbergError::Validation { message, .. }) => {
+            assert!(message.contains("whitespace"), "Error should mention whitespace");
+        }
+        _ => panic!("Expected Validation error"),
+    }
+}
+
+/// Test validator registration with failed initialization.
+#[test]
+fn test_validator_registration_with_failed_init_fails() {
+    let mut registry = ValidatorRegistry::new();
+
+    let validator = Arc::new(FailingInitValidator {
+        name: "failing-validator".to_string(),
+    });
+
+    let result = registry.register(validator);
+    assert!(result.is_err(), "Registration with failed init should fail");
+
+    match result {
+        Err(KreuzbergError::Plugin { .. }) => {
+            // Expected error type
+        }
+        _ => panic!("Expected Plugin error"),
+    }
+
+    // Validator should not be in the list
+    assert_eq!(registry.list().len(), 0, "Failed validator should not be registered");
+}
+
+/// Test clearing all validators.
+#[test]
+fn test_clear_validators_succeeds() {
+    let mut registry = ValidatorRegistry::new();
+
+    // Register multiple validators
+    let v1 = Arc::new(MockValidator {
+        name: "validator-1".to_string(),
+        should_fail: false,
+    });
+    let v2 = Arc::new(MockValidator {
+        name: "validator-2".to_string(),
+        should_fail: false,
+    });
+
+    registry.register(v1).unwrap();
+    registry.register(v2).unwrap();
+    assert_eq!(registry.list().len(), 2);
+
+    // Clear all
+    let result = registry.shutdown_all();
+    assert!(result.is_ok(), "Clear should succeed");
+    assert_eq!(registry.list().len(), 0, "Registry should be empty after clear");
+}
+
+/// Test getting all validators in priority order.
+#[test]
+fn test_get_all_validators_respects_priority() {
+    let mut registry = ValidatorRegistry::new();
+
+    struct PriorityValidator {
+        name: String,
+        priority: i32,
+    }
+
+    impl Plugin for PriorityValidator {
+        fn name(&self) -> &str {
+            &self.name
+        }
+        fn version(&self) -> String {
+            "1.0.0".to_string()
+        }
+        fn initialize(&self) -> Result<()> {
+            Ok(())
+        }
+        fn shutdown(&self) -> Result<()> {
+            Ok(())
+        }
+    }
+
+    #[async_trait]
+    impl Validator for PriorityValidator {
+        async fn validate(&self, _result: &ExtractionResult, _config: &ExtractionConfig) -> Result<()> {
+            Ok(())
+        }
+        fn priority(&self) -> i32 {
+            self.priority
+        }
+    }
+
+    let low = Arc::new(PriorityValidator {
+        name: "low-priority".to_string(),
+        priority: 10,
+    });
+    let medium = Arc::new(PriorityValidator {
+        name: "medium-priority".to_string(),
+        priority: 50,
+    });
+    let high = Arc::new(PriorityValidator {
+        name: "high-priority".to_string(),
+        priority: 100,
+    });
+
+    registry.register(medium).unwrap();
+    registry.register(low).unwrap();
+    registry.register(high).unwrap();
+
+    let all = registry.get_all();
+    assert_eq!(all.len(), 3, "Should have three validators");
+
+    // Should be in descending priority order
+    assert_eq!(all[0].name(), "high-priority");
+    assert_eq!(all[1].name(), "medium-priority");
+    assert_eq!(all[2].name(), "low-priority");
+}
+
+// ===== Extractor Registry Tests =====
+
+/// Test extractor registration and retrieval.
+#[test]
+fn test_extractor_registration_succeeds() {
+    let mut registry = DocumentExtractorRegistry::new();
+
+    let extractor = Arc::new(MockExtractor {
+        name: "test-extractor".to_string(),
+        mime_types: vec!["text/plain"],
+        priority: 50,
+    });
+
+    let result = registry.register(extractor);
+    assert!(result.is_ok(), "Extractor registration should succeed");
+
+    let list = registry.list();
+    assert_eq!(list.len(), 1, "Should have one extractor");
+    assert!(list.contains(&"test-extractor".to_string()));
+}
+
+/// Test extractor retrieval by MIME type.
+#[test]
+fn test_get_extractor_by_mime_type_succeeds() {
+    let mut registry = DocumentExtractorRegistry::new();
+
+    let extractor = Arc::new(MockExtractor {
+        name: "pdf-extractor".to_string(),
+        mime_types: vec!["application/pdf"],
+        priority: 50,
+    });
+
+    registry.register(extractor).unwrap();
+
+    let result = registry.get("application/pdf");
+    assert!(result.is_ok(), "Should find extractor for PDF");
+    assert_eq!(result.unwrap().name(), "pdf-extractor");
+}
+
+/// Test extractor not found for unsupported MIME type.
+#[test]
+fn test_get_extractor_for_unsupported_mime_fails() {
+    let registry = DocumentExtractorRegistry::new();
+
+    let result = registry.get("application/nonexistent");
+    assert!(result.is_err(), "Should not find extractor for unsupported MIME type");
+
+    match result {
+        Err(KreuzbergError::UnsupportedFormat(mime)) => {
+            assert_eq!(mime, "application/nonexistent");
+        }
+        _ => panic!("Expected UnsupportedFormat error"),
+    }
+}
+
+/// Test extractor priority selection.
+#[test]
+fn test_extractor_priority_selection() {
+    let mut registry = DocumentExtractorRegistry::new();
+
+    let low_priority = Arc::new(MockExtractor {
+        name: "low-priority-extractor".to_string(),
+        mime_types: vec!["text/plain"],
+        priority: 10,
+    });
+
+    let high_priority = Arc::new(MockExtractor {
+        name: "high-priority-extractor".to_string(),
+        mime_types: vec!["text/plain"],
+        priority: 100,
+    });
+
+    registry.register(low_priority).unwrap();
+    registry.register(high_priority).unwrap();
+
+    // Should get the high priority extractor
+    let result = registry.get("text/plain").unwrap();
+    assert_eq!(
+        result.name(),
+        "high-priority-extractor",
+        "Should select highest priority extractor"
+    );
+}
+
+/// Test extractor wildcard MIME type matching.
+#[test]
+fn test_extractor_wildcard_mime_matching() {
+    let mut registry = DocumentExtractorRegistry::new();
+
+    let extractor = Arc::new(MockExtractor {
+        name: "text-extractor".to_string(),
+        mime_types: vec!["text/*"],
+        priority: 50,
+    });
+
+    registry.register(extractor).unwrap();
+
+    // Should match text/plain
+    let result = registry.get("text/plain");
+    assert!(result.is_ok(), "Should match text/plain with text/*");
+    assert_eq!(result.unwrap().name(), "text-extractor");
+
+    // Should match text/html
+    let result = registry.get("text/html");
+    assert!(result.is_ok(), "Should match text/html with text/*");
+    assert_eq!(result.unwrap().name(), "text-extractor");
+
+    // Should not match application/pdf
+    let result = registry.get("application/pdf");
+    assert!(result.is_err(), "Should not match application/pdf with text/*");
+}
+
+/// Test extractor unregistration.
+#[test]
+fn test_extractor_unregistration_succeeds() {
+    let mut registry = DocumentExtractorRegistry::new();
+
+    let extractor = Arc::new(MockExtractor {
+        name: "temp-extractor".to_string(),
+        mime_types: vec!["text/plain"],
+        priority: 50,
+    });
+
+    registry.register(extractor).unwrap();
+    assert_eq!(registry.list().len(), 1);
+
+    let result = registry.remove("temp-extractor");
+    assert!(result.is_ok(), "Unregistration should succeed");
+    assert_eq!(registry.list().len(), 0, "Registry should be empty after removal");
+
+    // Should no longer find extractor for MIME type
+    let lookup_result = registry.get("text/plain");
+    assert!(lookup_result.is_err(), "Should not find extractor after removal");
+}
+
+/// Test extractor registration with multiple MIME types.
+#[test]
+fn test_extractor_multiple_mime_types() {
+    let mut registry = DocumentExtractorRegistry::new();
+
+    let extractor = Arc::new(MockExtractor {
+        name: "multi-format-extractor".to_string(),
+        mime_types: vec!["application/pdf", "application/vnd.ms-excel", "text/csv"],
+        priority: 50,
+    });
+
+    registry.register(extractor).unwrap();
+
+    // Should find for all MIME types
+    assert!(registry.get("application/pdf").is_ok());
+    assert!(registry.get("application/vnd.ms-excel").is_ok());
+    assert!(registry.get("text/csv").is_ok());
+
+    // All should return the same extractor
+    assert_eq!(
+        registry.get("application/pdf").unwrap().name(),
+        "multi-format-extractor"
+    );
+    assert_eq!(registry.get("text/csv").unwrap().name(), "multi-format-extractor");
+}
+
+/// Test clearing all extractors.
+#[test]
+fn test_clear_extractors_succeeds() {
+    let mut registry = DocumentExtractorRegistry::new();
+
+    let e1 = Arc::new(MockExtractor {
+        name: "extractor-1".to_string(),
+        mime_types: vec!["text/plain"],
+        priority: 50,
+    });
+    let e2 = Arc::new(MockExtractor {
+        name: "extractor-2".to_string(),
+        mime_types: vec!["application/pdf"],
+        priority: 50,
+    });
+
+    registry.register(e1).unwrap();
+    registry.register(e2).unwrap();
+    assert_eq!(registry.list().len(), 2);
+
+    let result = registry.shutdown_all();
+    assert!(result.is_ok(), "Clear should succeed");
+    assert_eq!(registry.list().len(), 0, "Registry should be empty after clear");
+}
+
+/// Test extractor registration with empty name fails.
+#[test]
+fn test_extractor_registration_with_empty_name_fails() {
+    let mut registry = DocumentExtractorRegistry::new();
+
+    let extractor = Arc::new(MockExtractor {
+        name: "".to_string(),
+        mime_types: vec!["text/plain"],
+        priority: 50,
+    });
+
+    let result = registry.register(extractor);
+    assert!(result.is_err(), "Registration with empty name should fail");
+
+    match result {
+        Err(KreuzbergError::Validation { message, .. }) => {
+            assert!(message.contains("empty"), "Error should mention empty name");
+        }
+        _ => panic!("Expected Validation error"),
+    }
+}
+
+/// Test extractor registration with whitespace fails.
+#[test]
+fn test_extractor_registration_with_whitespace_fails() {
+    let mut registry = DocumentExtractorRegistry::new();
+
+    let extractor = Arc::new(MockExtractor {
+        name: "extractor with spaces".to_string(),
+        mime_types: vec!["text/plain"],
+        priority: 50,
+    });
+
+    let result = registry.register(extractor);
+    assert!(result.is_err(), "Registration with whitespace should fail");
+
+    match result {
+        Err(KreuzbergError::Validation { message, .. }) => {
+            assert!(message.contains("whitespace"), "Error should mention whitespace");
+        }
+        _ => panic!("Expected Validation error"),
+    }
+}