kreuzberg 4.0.0.rc1

data/vendor/kreuzberg/src/plugins/validator.rs

@@ -0,0 +1,955 @@
+//! Validator plugin trait.
+//!
+//! This module defines the trait for implementing custom validation logic.
+
+use crate::Result;
+use crate::core::config::ExtractionConfig;
+use crate::plugins::Plugin;
+use crate::types::ExtractionResult;
+use async_trait::async_trait;
+use std::sync::Arc;
+
+/// Trait for validator plugins.
+///
+/// Validators check extraction results for quality, completeness, or correctness.
+/// Unlike post-processors, validator errors **fail fast** - if a validator returns
+/// an error, the extraction fails immediately.
+///
+/// # Use Cases
+///
+/// - **Quality Gates**: Ensure extracted content meets minimum quality standards
+/// - **Compliance**: Verify content meets regulatory requirements
+/// - **Content Filtering**: Reject documents containing unwanted content
+/// - **Format Validation**: Verify extracted content structure
+/// - **Security Checks**: Scan for malicious content
+///
+/// # Error Handling
+///
+/// Validator errors are **fatal** - they cause the extraction to fail and bubble up
+/// to the caller. Use validators for hard requirements that must be met.
+///
+/// For non-fatal checks, use post-processors instead.
+///
+/// # Thread Safety
+///
+/// Validators must be thread-safe (`Send + Sync`).
+///
+/// # Example
+///
+/// ```rust
+/// use kreuzberg::plugins::{Plugin, Validator};
+/// use kreuzberg::{Result, ExtractionResult, ExtractionConfig, KreuzbergError};
+/// use async_trait::async_trait;
+///
+/// /// Validate that extracted content has minimum length
+/// struct MinimumLengthValidator {
+///     min_length: usize,
+/// }
+///
+/// impl Plugin for MinimumLengthValidator {
+///     fn name(&self) -> &str { "min-length-validator" }
+///     fn version(&self) -> String { "1.0.0".to_string() }
+///     fn initialize(&self) -> Result<()> { Ok(()) }
+///     fn shutdown(&self) -> Result<()> { Ok(()) }
+/// }
+///
+/// #[async_trait]
+/// impl Validator for MinimumLengthValidator {
+///     async fn validate(&self, result: &ExtractionResult, config: &ExtractionConfig)
+///         -> Result<()> {
+///         if result.content.len() < self.min_length {
+///             return Err(KreuzbergError::validation(format!(
+///                 "Content too short: {} < {} characters",
+///                 result.content.len(),
+///                 self.min_length
+///             )));
+///         }
+///         Ok(())
+///     }
+/// }
+/// ```
+#[async_trait]
+pub trait Validator: Plugin {
+    /// Validate an extraction result.
+    ///
+    /// Check the extraction result and return `Ok(())` if valid, or an error
+    /// if validation fails.
+    ///
+    /// # Arguments
+    ///
+    /// * `result` - The extraction result to validate
+    /// * `config` - Extraction configuration
+    ///
+    /// # Returns
+    ///
+    /// - `Ok(())` if validation passes
+    /// - `Err(...)` if validation fails (extraction will fail)
+    ///
+    /// # Errors
+    ///
+    /// - `KreuzbergError::Validation` - Validation failed
+    /// - Any other error type appropriate for the failure
+    ///
+    /// # Example - Content Length Validation
+    ///
+    /// ```rust
+    /// # use kreuzberg::plugins::{Plugin, Validator};
+    /// # use kreuzberg::{Result, ExtractionResult, ExtractionConfig, KreuzbergError};
+    /// # use async_trait::async_trait;
+    /// # struct ContentLengthValidator { min: usize, max: usize }
+    /// # impl Plugin for ContentLengthValidator {
+    /// #     fn name(&self) -> &str { "length-validator" }
+    /// #     fn version(&self) -> String { "1.0.0".to_string() }
+    /// #     fn initialize(&self) -> Result<()> { Ok(()) }
+    /// #     fn shutdown(&self) -> Result<()> { Ok(()) }
+    /// # }
+    /// # #[async_trait]
+    /// # impl Validator for ContentLengthValidator {
+    /// async fn validate(&self, result: &ExtractionResult, config: &ExtractionConfig)
+    ///     -> Result<()> {
+    ///     let length = result.content.len();
+    ///
+    ///     if length < self.min {
+    ///         return Err(KreuzbergError::validation(format!(
+    ///             "Content too short: {} < {} characters",
+    ///             length, self.min
+    ///         )));
+    ///     }
+    ///
+    ///     if length > self.max {
+    ///         return Err(KreuzbergError::validation(format!(
+    ///             "Content too long: {} > {} characters",
+    ///             length, self.max
+    ///         )));
+    ///     }
+    ///
+    ///     Ok(())
+    /// }
+    /// # }
+    /// ```
+    ///
+    /// # Example - Quality Score Validation
+    ///
+    /// ```rust
+    /// # use kreuzberg::plugins::{Plugin, Validator};
+    /// # use kreuzberg::{Result, ExtractionResult, ExtractionConfig, KreuzbergError};
+    /// # use async_trait::async_trait;
+    /// # struct QualityValidator { min_score: f64 }
+    /// # impl Plugin for QualityValidator {
+    /// #     fn name(&self) -> &str { "quality-validator" }
+    /// #     fn version(&self) -> String { "1.0.0".to_string() }
+    /// #     fn initialize(&self) -> Result<()> { Ok(()) }
+    /// #     fn shutdown(&self) -> Result<()> { Ok(()) }
+    /// # }
+    /// # #[async_trait]
+    /// # impl Validator for QualityValidator {
+    /// async fn validate(&self, result: &ExtractionResult, config: &ExtractionConfig)
+    ///     -> Result<()> {
+    ///     // Check if quality_score exists in metadata
+    ///     let score = result.metadata
+    ///         .additional
+    ///         .get("quality_score")
+    ///         .and_then(|v| v.as_f64())
+    ///         .unwrap_or(0.0);
+    ///
+    ///     if score < self.min_score {
+    ///         return Err(KreuzbergError::validation(format!(
+    ///             "Quality score too low: {} < {}",
+    ///             score, self.min_score
+    ///         )));
+    ///     }
+    ///
+    ///     Ok(())
+    /// }
+    /// # }
+    /// ```
+    ///
+    /// # Example - Security Validation
+    ///
+    /// ```rust
+    /// # use kreuzberg::plugins::{Plugin, Validator};
+    /// # use kreuzberg::{Result, ExtractionResult, ExtractionConfig, KreuzbergError};
+    /// # use async_trait::async_trait;
+    /// # struct SecurityValidator { blocked_patterns: Vec<String> }
+    /// # impl Plugin for SecurityValidator {
+    /// #     fn name(&self) -> &str { "security-validator" }
+    /// #     fn version(&self) -> String { "1.0.0".to_string() }
+    /// #     fn initialize(&self) -> Result<()> { Ok(()) }
+    /// #     fn shutdown(&self) -> Result<()> { Ok(()) }
+    /// # }
+    /// # #[async_trait]
+    /// # impl Validator for SecurityValidator {
+    /// async fn validate(&self, result: &ExtractionResult, config: &ExtractionConfig)
+    ///     -> Result<()> {
+    ///     // Check for blocked patterns
+    ///     for pattern in &self.blocked_patterns {
+    ///         if result.content.contains(pattern) {
+    ///             return Err(KreuzbergError::validation(format!(
+    ///                 "Content contains blocked pattern: {}",
+    ///                 pattern
+    ///             )));
+    ///         }
+    ///     }
+    ///
+    ///     Ok(())
+    /// }
+    /// # }
+    /// ```
+    async fn validate(&self, result: &ExtractionResult, config: &ExtractionConfig) -> Result<()>;
+
+    /// Optional: Check if this validator should run for a given result.
+    ///
+    /// Allows conditional validation based on MIME type, metadata, or content.
+    /// Defaults to `true` (always run).
+    ///
+    /// # Arguments
+    ///
+    /// * `result` - The extraction result to check
+    /// * `config` - Extraction configuration
+    ///
+    /// # Returns
+    ///
+    /// `true` if the validator should run, `false` to skip.
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// # use kreuzberg::plugins::{Plugin, Validator};
+    /// # use kreuzberg::{Result, ExtractionResult, ExtractionConfig};
+    /// # use async_trait::async_trait;
+    /// # struct PdfValidator;
+    /// # impl Plugin for PdfValidator {
+    /// #     fn name(&self) -> &str { "pdf-validator" }
+    /// #     fn version(&self) -> String { "1.0.0".to_string() }
+    /// #     fn initialize(&self) -> Result<()> { Ok(()) }
+    /// #     fn shutdown(&self) -> Result<()> { Ok(()) }
+    /// # }
+    /// # #[async_trait]
+    /// # impl Validator for PdfValidator {
+    /// #     async fn validate(&self, _: &ExtractionResult, _: &ExtractionConfig) -> Result<()> { Ok(()) }
+    /// /// Only validate PDF documents
+    /// fn should_validate(&self, result: &ExtractionResult, config: &ExtractionConfig) -> bool {
+    ///     result.mime_type == "application/pdf"
+    /// }
+    /// # }
+    /// ```
+    fn should_validate(&self, _result: &ExtractionResult, _config: &ExtractionConfig) -> bool {
+        true
+    }
+
+    /// Optional: Get the validation priority.
+    ///
+    /// Higher priority validators run first. Useful for ordering validation checks
+    /// (e.g., run cheap validations before expensive ones).
+    ///
+    /// Default priority is 50.
+    ///
+    /// # Returns
+    ///
+    /// Priority value (higher = runs earlier).
+    ///
+    /// # Example
+    ///
+    /// ```rust
+    /// # use kreuzberg::plugins::{Plugin, Validator};
+    /// # use kreuzberg::{Result, ExtractionResult, ExtractionConfig};
+    /// # use async_trait::async_trait;
+    /// # struct FastValidator;
+    /// # impl Plugin for FastValidator {
+    /// #     fn name(&self) -> &str { "fast-validator" }
+    /// #     fn version(&self) -> String { "1.0.0".to_string() }
+    /// #     fn initialize(&self) -> Result<()> { Ok(()) }
+    /// #     fn shutdown(&self) -> Result<()> { Ok(()) }
+    /// # }
+    /// # #[async_trait]
+    /// # impl Validator for FastValidator {
+    /// #     async fn validate(&self, _: &ExtractionResult, _: &ExtractionConfig) -> Result<()> { Ok(()) }
+    /// /// Run this validator first (it's fast)
+    /// fn priority(&self) -> i32 {
+    ///     100
+    /// }
+    /// # }
+    /// ```
+    fn priority(&self) -> i32 {
+        50
+    }
+}
+
+// Public registration APIs
+
+/// Register a validator with the global registry.
+///
+/// The validator will be registered with its default priority and will be called
+/// during extraction validation. The validator's `name()` method is used as the
+/// registration name.
+///
+/// # Arguments
+///
+/// * `validator` - The validator implementation wrapped in Arc
+///
+/// # Returns
+///
+/// - `Ok(())` if registration succeeded
+/// - `Err(...)` if validation failed or initialization failed
+///
+/// # Errors
+///
+/// - `KreuzbergError::Validation` - Invalid validator name (empty or contains whitespace)
+/// - Any error from the validator's `initialize()` method
+///
+/// # Example
+///
+/// ```rust
+/// use kreuzberg::plugins::{Plugin, Validator, register_validator};
+/// use kreuzberg::{Result, ExtractionResult, ExtractionConfig, KreuzbergError};
+/// use async_trait::async_trait;
+/// use std::sync::Arc;
+///
+/// struct MinLengthValidator { min_length: usize }
+///
+/// impl Plugin for MinLengthValidator {
+///     fn name(&self) -> &str { "min-length" }
+///     fn version(&self) -> String { "1.0.0".to_string() }
+///     fn initialize(&self) -> Result<()> { Ok(()) }
+///     fn shutdown(&self) -> Result<()> { Ok(()) }
+/// }
+///
+/// #[async_trait]
+/// impl Validator for MinLengthValidator {
+///     async fn validate(&self, result: &ExtractionResult, _: &ExtractionConfig) -> Result<()> {
+///         if result.content.len() < self.min_length {
+///             return Err(KreuzbergError::validation(
+///                 format!("Content too short: {} < {}", result.content.len(), self.min_length)
+///             ));
+///         }
+///         Ok(())
+///     }
+/// }
+///
+/// # tokio_test::block_on(async {
+/// let validator = Arc::new(MinLengthValidator { min_length: 10 });
+/// register_validator(validator)?;
+/// # Ok::<(), KreuzbergError>(())
+/// # });
+/// ```
+pub fn register_validator(validator: Arc<dyn Validator>) -> crate::Result<()> {
+    use crate::plugins::registry::get_validator_registry;
+
+    let registry = get_validator_registry();
+    let mut registry = registry
+        .write()
+        .expect("~keep Failed to acquire write lock on validator registry"); // ~keep
+
+    registry.register(validator)
+}
+
+/// Unregister a validator by name.
+///
+/// Removes the validator from the global registry and calls its `shutdown()` method.
+///
+/// # Arguments
+///
+/// * `name` - Name of the validator to unregister
+///
+/// # Returns
+///
+/// - `Ok(())` if the validator was unregistered or didn't exist
+/// - `Err(...)` if the shutdown method failed
+///
+/// # Example
+///
+/// ```rust
+/// use kreuzberg::plugins::unregister_validator;
+///
+/// # tokio_test::block_on(async {
+/// unregister_validator("min-length")?;
+/// # Ok::<(), kreuzberg::KreuzbergError>(())
+/// # });
+/// ```
+pub fn unregister_validator(name: &str) -> crate::Result<()> {
+    use crate::plugins::registry::get_validator_registry;
+
+    let registry = get_validator_registry();
+    let mut registry = registry
+        .write()
+        .expect("~keep Failed to acquire write lock on validator registry"); // ~keep
+
+    registry.remove(name)
+}
+
+/// List all registered validators.
+///
+/// Returns the names of all validators currently registered in the global registry.
+///
+/// # Returns
+///
+/// A vector of validator names.
+///
+/// # Example
+///
+/// ```rust
+/// use kreuzberg::plugins::list_validators;
+///
+/// # tokio_test::block_on(async {
+/// let validators = list_validators()?;
+/// for name in validators {
+///     println!("Registered validator: {}", name);
+/// }
+/// # Ok::<(), kreuzberg::KreuzbergError>(())
+/// # });
+/// ```
+pub fn list_validators() -> crate::Result<Vec<String>> {
+    use crate::plugins::registry::get_validator_registry;
+
+    let registry = get_validator_registry();
+    let registry = registry
+        .read()
+        .expect("~keep Failed to acquire read lock on validator registry"); // ~keep
+
+    Ok(registry.list())
+}
+
+/// Clear all validators from the global registry.
+///
+/// Removes all validators and calls their `shutdown()` methods.
+///
+/// # Returns
+///
+/// - `Ok(())` if all validators were cleared successfully
+/// - `Err(...)` if any shutdown method failed
+///
+/// # Example
+///
+/// ```rust
+/// use kreuzberg::plugins::clear_validators;
+///
+/// # tokio_test::block_on(async {
+/// clear_validators()?;
+/// # Ok::<(), kreuzberg::KreuzbergError>(())
+/// # });
+/// ```
+pub fn clear_validators() -> crate::Result<()> {
+    use crate::plugins::registry::get_validator_registry;
+
+    let registry = get_validator_registry();
+    let mut registry = registry
+        .write()
+        .expect("~keep Failed to acquire write lock on validator registry"); // ~keep
+
+    registry.shutdown_all()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::KreuzbergError;
+    use std::collections::HashMap;
+
+    struct MockValidator {
+        should_fail: bool,
+    }
+
+    impl Plugin for MockValidator {
+        fn name(&self) -> &str {
+            "mock-validator"
+        }
+
+        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("Validation failed".to_string()))
+            } else {
+                Ok(())
+            }
+        }
+    }
+
+    #[tokio::test]
+    async fn test_validator_success() {
+        let validator = MockValidator { should_fail: false };
+
+        let result = ExtractionResult {
+            content: "test content".to_string(),
+            mime_type: "text/plain".to_string(),
+            metadata: crate::types::Metadata::default(),
+            tables: vec![],
+            detected_languages: None,
+            chunks: None,
+            images: None,
+        };
+
+        let config = ExtractionConfig::default();
+        assert!(validator.validate(&result, &config).await.is_ok());
+    }
+
+    #[tokio::test]
+    async fn test_validator_failure() {
+        let validator = MockValidator { should_fail: true };
+
+        let result = ExtractionResult {
+            content: "test content".to_string(),
+            mime_type: "text/plain".to_string(),
+            metadata: crate::types::Metadata::default(),
+            tables: vec![],
+            detected_languages: None,
+            chunks: None,
+            images: None,
+        };
+
+        let config = ExtractionConfig::default();
+        let validation_result = validator.validate(&result, &config).await;
+
+        assert!(matches!(validation_result, Err(KreuzbergError::Validation { .. })));
+    }
+
+    #[test]
+    fn test_validator_should_validate_default() {
+        let validator = MockValidator { should_fail: false };
+
+        let result = ExtractionResult {
+            content: "test".to_string(),
+            mime_type: "text/plain".to_string(),
+            metadata: crate::types::Metadata::default(),
+            tables: vec![],
+            detected_languages: None,
+            chunks: None,
+            images: None,
+        };
+
+        let config = ExtractionConfig::default();
+
+        assert!(validator.should_validate(&result, &config));
+    }
+
+    #[test]
+    fn test_validator_priority_default() {
+        let validator = MockValidator { should_fail: false };
+        assert_eq!(validator.priority(), 50);
+    }
+
+    #[tokio::test]
+    async fn test_validator_plugin_interface() {
+        let validator = MockValidator { should_fail: false };
+
+        assert_eq!(validator.name(), "mock-validator");
+        assert_eq!(validator.version(), "1.0.0");
+        assert!(validator.initialize().is_ok());
+        assert!(validator.shutdown().is_ok());
+    }
+
+    #[tokio::test]
+    async fn test_validator_empty_content() {
+        let validator = MockValidator { should_fail: false };
+
+        let result = ExtractionResult {
+            content: String::new(),
+            mime_type: "text/plain".to_string(),
+            metadata: crate::types::Metadata::default(),
+            tables: vec![],
+            detected_languages: None,
+            chunks: None,
+            images: None,
+        };
+
+        let config = ExtractionConfig::default();
+        assert!(validator.validate(&result, &config).await.is_ok());
+    }
+
+    #[test]
+    fn test_validator_should_validate_conditional() {
+        struct PdfOnlyValidator;
+
+        impl Plugin for PdfOnlyValidator {
+            fn name(&self) -> &str {
+                "pdf-only"
+            }
+            fn version(&self) -> String {
+                "1.0.0".to_string()
+            }
+            fn initialize(&self) -> Result<()> {
+                Ok(())
+            }
+            fn shutdown(&self) -> Result<()> {
+                Ok(())
+            }
+        }
+
+        #[async_trait]
+        impl Validator for PdfOnlyValidator {
+            async fn validate(&self, _result: &ExtractionResult, _config: &ExtractionConfig) -> Result<()> {
+                Ok(())
+            }
+
+            fn should_validate(&self, result: &ExtractionResult, _config: &ExtractionConfig) -> bool {
+                result.mime_type == "application/pdf"
+            }
+        }
+
+        let validator = PdfOnlyValidator;
+        let config = ExtractionConfig::default();
+
+        let pdf_result = ExtractionResult {
+            content: "test".to_string(),
+            mime_type: "application/pdf".to_string(),
+            metadata: crate::types::Metadata::default(),
+            tables: vec![],
+            detected_languages: None,
+            chunks: None,
+            images: None,
+        };
+
+        let txt_result = ExtractionResult {
+            content: "test".to_string(),
+            mime_type: "text/plain".to_string(),
+            metadata: crate::types::Metadata::default(),
+            tables: vec![],
+            detected_languages: None,
+            chunks: None,
+            images: None,
+        };
+
+        assert!(validator.should_validate(&pdf_result, &config));
+        assert!(!validator.should_validate(&txt_result, &config));
+    }
+
+    #[test]
+    fn test_validator_priority_ranges() {
+        struct HighPriorityValidator;
+        struct LowPriorityValidator;
+
+        impl Plugin for HighPriorityValidator {
+            fn name(&self) -> &str {
+                "high-priority"
+            }
+            fn version(&self) -> String {
+                "1.0.0".to_string()
+            }
+            fn initialize(&self) -> Result<()> {
+                Ok(())
+            }
+            fn shutdown(&self) -> Result<()> {
+                Ok(())
+            }
+        }
+
+        impl Plugin for LowPriorityValidator {
+            fn name(&self) -> &str {
+                "low-priority"
+            }
+            fn version(&self) -> String {
+                "1.0.0".to_string()
+            }
+            fn initialize(&self) -> Result<()> {
+                Ok(())
+            }
+            fn shutdown(&self) -> Result<()> {
+                Ok(())
+            }
+        }
+
+        #[async_trait]
+        impl Validator for HighPriorityValidator {
+            async fn validate(&self, _result: &ExtractionResult, _config: &ExtractionConfig) -> Result<()> {
+                Ok(())
+            }
+
+            fn priority(&self) -> i32 {
+                100
+            }
+        }
+
+        #[async_trait]
+        impl Validator for LowPriorityValidator {
+            async fn validate(&self, _result: &ExtractionResult, _config: &ExtractionConfig) -> Result<()> {
+                Ok(())
+            }
+
+            fn priority(&self) -> i32 {
+                10
+            }
+        }
+
+        let high = HighPriorityValidator;
+        let low = LowPriorityValidator;
+
+        assert_eq!(high.priority(), 100);
+        assert_eq!(low.priority(), 10);
+        assert!(high.priority() > low.priority());
+    }
+
+    #[tokio::test]
+    async fn test_validator_error_message() {
+        let validator = MockValidator { should_fail: true };
+
+        let result = ExtractionResult {
+            content: "test".to_string(),
+            mime_type: "text/plain".to_string(),
+            metadata: crate::types::Metadata::default(),
+            tables: vec![],
+            detected_languages: None,
+            chunks: None,
+            images: None,
+        };
+
+        let config = ExtractionConfig::default();
+        let err = validator.validate(&result, &config).await.unwrap_err();
+
+        match err {
+            KreuzbergError::Validation { message: msg, .. } => {
+                assert_eq!(msg, "Validation failed");
+            }
+            _ => panic!("Expected Validation error"),
+        }
+    }
+
+    #[tokio::test]
+    async fn test_validator_with_metadata() {
+        let validator = MockValidator { should_fail: false };
+
+        let mut additional = HashMap::new();
+        additional.insert("quality_score".to_string(), serde_json::json!(0.95));
+
+        let result = ExtractionResult {
+            content: "test".to_string(),
+            mime_type: "text/plain".to_string(),
+            metadata: crate::types::Metadata {
+                additional,
+                ..Default::default()
+            },
+            tables: vec![],
+            detected_languages: None,
+            chunks: None,
+            images: None,
+        };
+
+        let config = ExtractionConfig::default();
+        assert!(validator.validate(&result, &config).await.is_ok());
+    }
+
+    #[tokio::test]
+    async fn test_validator_with_tables() {
+        use crate::types::Table;
+
+        let validator = MockValidator { should_fail: false };
+
+        let table = Table {
+            cells: vec![vec!["A".to_string(), "B".to_string()]],
+            markdown: "| A | B |".to_string(),
+            page_number: 0,
+        };
+
+        let result = ExtractionResult {
+            content: "test".to_string(),
+            mime_type: "text/plain".to_string(),
+            metadata: crate::types::Metadata::default(),
+            tables: vec![table],
+            detected_languages: None,
+            chunks: None,
+            images: None,
+        };
+
+        let config = ExtractionConfig::default();
+        assert!(validator.validate(&result, &config).await.is_ok());
+    }
+
+    #[tokio::test]
+    async fn test_validator_different_mime_types() {
+        let validator = MockValidator { should_fail: false };
+        let config = ExtractionConfig::default();
+
+        let mime_types = vec![
+            "text/plain",
+            "application/pdf",
+            "application/json",
+            "text/html",
+            "image/png",
+        ];
+
+        for mime_type in mime_types {
+            let result = ExtractionResult {
+                content: "test".to_string(),
+                mime_type: mime_type.to_string(),
+                metadata: crate::types::Metadata::default(),
+                tables: vec![],
+                detected_languages: None,
+                chunks: None,
+                images: None,
+            };
+
+            assert!(validator.validate(&result, &config).await.is_ok());
+        }
+    }
+
+    #[tokio::test]
+    async fn test_validator_long_content() {
+        let validator = MockValidator { should_fail: false };
+
+        let result = ExtractionResult {
+            content: "test content ".repeat(10000),
+            mime_type: "text/plain".to_string(),
+            metadata: crate::types::Metadata::default(),
+            tables: vec![],
+            detected_languages: None,
+            chunks: None,
+            images: None,
+        };
+
+        let config = ExtractionConfig::default();
+        assert!(validator.validate(&result, &config).await.is_ok());
+    }
+
+    // Tests for public registration APIs
+
+    #[test]
+    fn test_register_validator() {
+        use std::sync::Arc;
+
+        let validator = Arc::new(MockValidator { should_fail: false });
+        let result = super::register_validator(validator);
+        assert!(result.is_ok());
+
+        let _ = super::unregister_validator("mock-validator");
+    }
+
+    #[test]
+    fn test_unregister_validator() {
+        use std::sync::Arc;
+
+        let validator = Arc::new(MockValidator { should_fail: false });
+        super::register_validator(validator).unwrap();
+
+        let result = super::unregister_validator("mock-validator");
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn test_unregister_nonexistent_validator() {
+        let result = super::unregister_validator("nonexistent-validator-xyz");
+        assert!(result.is_ok());
+    }
+
+    #[test]
+    fn test_list_validators() {
+        use std::sync::Arc;
+
+        super::clear_validators().unwrap();
+
+        let validator1 = Arc::new(MockValidator { should_fail: false });
+        // Both validators have the same name, so only one will be registered
+        let validator2 = Arc::new(MockValidator { should_fail: false });
+
+        let list_before = super::list_validators().unwrap();
+        assert_eq!(list_before.len(), 0);
+
+        super::register_validator(validator1).unwrap();
+        super::register_validator(validator2).unwrap();
+
+        let list = super::list_validators().unwrap();
+        // Only 1 validator registered since they have the same name
+        assert_eq!(list.len(), 1);
+        assert!(list.contains(&"mock-validator".to_string()));
+
+        super::unregister_validator("mock-validator").unwrap();
+    }
+
+    #[test]
+    fn test_clear_validators() {
+        use std::sync::Arc;
+
+        super::clear_validators().unwrap();
+
+        let validator1 = Arc::new(MockValidator { should_fail: false });
+        let validator2 = Arc::new(MockValidator { should_fail: false });
+
+        super::register_validator(validator1).unwrap();
+        super::register_validator(validator2).unwrap();
+
+        // Verify at least one validator is registered
+        let list_before = super::list_validators().unwrap();
+        assert!(!list_before.is_empty());
+
+        let result = super::clear_validators();
+        assert!(result.is_ok());
+
+        let list = super::list_validators().unwrap();
+        assert_eq!(list.len(), 0);
+    }
+
+    #[test]
+    fn test_register_validator_with_invalid_name() {
+        use std::sync::Arc;
+
+        struct InvalidNameValidator;
+        impl Plugin for InvalidNameValidator {
+            fn name(&self) -> &str {
+                "invalid name with spaces"
+            }
+            fn version(&self) -> String {
+                "1.0.0".to_string()
+            }
+            fn initialize(&self) -> Result<()> {
+                Ok(())
+            }
+            fn shutdown(&self) -> Result<()> {
+                Ok(())
+            }
+        }
+
+        #[async_trait]
+        impl Validator for InvalidNameValidator {
+            async fn validate(&self, _: &ExtractionResult, _: &ExtractionConfig) -> Result<()> {
+                Ok(())
+            }
+        }
+
+        let validator = Arc::new(InvalidNameValidator);
+        let result = super::register_validator(validator);
+        assert!(matches!(result, Err(KreuzbergError::Validation { .. })));
+    }
+
+    #[test]
+    fn test_register_validator_with_empty_name() {
+        use std::sync::Arc;
+
+        struct EmptyNameValidator;
+        impl Plugin for EmptyNameValidator {
+            fn name(&self) -> &str {
+                ""
+            }
+            fn version(&self) -> String {
+                "1.0.0".to_string()
+            }
+            fn initialize(&self) -> Result<()> {
+                Ok(())
+            }
+            fn shutdown(&self) -> Result<()> {
+                Ok(())
+            }
+        }
+
+        #[async_trait]
+        impl Validator for EmptyNameValidator {
+            async fn validate(&self, _: &ExtractionResult, _: &ExtractionConfig) -> Result<()> {
+                Ok(())
+            }
+        }
+
+        let validator = Arc::new(EmptyNameValidator);
+        let result = super::register_validator(validator);
+        assert!(matches!(result, Err(KreuzbergError::Validation { .. })));
+    }
+}