kreuzberg 4.0.0.pre.rc.6 → 4.0.0.pre.rc.8

data/vendor/kreuzberg/tests/docbook_extractor_tests.rs

@@ -1,5 +1,7 @@
 //! Comprehensive tests for DocBook extractor supporting both 4.x and 5.x versions.
 
+#![cfg(feature = "xml")]
+
 use kreuzberg::core::config::ExtractionConfig;
 use kreuzberg::plugins::{DocumentExtractor, Plugin};
 use std::path::PathBuf;

data/vendor/kreuzberg/tests/email_integration.rs

@@ -3,6 +3,8 @@
 //! Tests for .eml (RFC822) email extraction.
 //! Validates metadata extraction, content extraction, HTML/plain text handling, and attachments.
 
+#![cfg(feature = "email")]
+
 use kreuzberg::core::config::ExtractionConfig;
 use kreuzberg::core::extractor::extract_bytes;
 

data/vendor/kreuzberg/tests/error_handling.rs

@@ -12,6 +12,7 @@ mod helpers;
 
 /// Test truncated PDF - incomplete PDF file.
 #[tokio::test]
+#[cfg(feature = "pdf")]
 async fn test_truncated_pdf() {
     let config = ExtractionConfig::default();
 
@@ -31,6 +32,7 @@ async fn test_truncated_pdf() {
 
 /// Test corrupted ZIP - malformed archive.
 #[tokio::test]
+#[cfg(feature = "archives")]
 async fn test_corrupted_zip() {
     let config = ExtractionConfig::default();
 
@@ -50,6 +52,7 @@ async fn test_corrupted_zip() {
 
 /// Test invalid XML - bad XML syntax.
 #[tokio::test]
+#[cfg(feature = "xml")]
 async fn test_invalid_xml() {
     let config = ExtractionConfig::default();
 
@@ -80,6 +83,7 @@ async fn test_invalid_xml() {
 
 /// Test corrupted image - invalid image data.
 #[tokio::test]
+#[cfg(feature = "ocr")]
 async fn test_corrupted_image() {
     let config = ExtractionConfig::default();
 
@@ -112,27 +116,28 @@ async fn test_empty_file() {
 
     let empty_data = b"";
 
-    let result_pdf = extract_bytes(empty_data, "application/pdf", &config).await;
     let result_text = extract_bytes(empty_data, "text/plain", &config).await;
-    let result_xml = extract_bytes(empty_data, "application/xml", &config).await;
-
-    match result_pdf {
-        Ok(extraction) => {
-            assert!(
-                extraction.content.is_empty(),
-                "Empty PDF should have empty content if it succeeds"
-            );
-            assert!(extraction.chunks.is_none(), "Chunks should be None");
-        }
-        Err(error) => {
-            assert!(
-                matches!(
-                    error,
-                    kreuzberg::KreuzbergError::Parsing { .. } | kreuzberg::KreuzbergError::Validation { .. }
-                ),
-                "Empty PDF should produce Parsing or Validation error, got: {:?}",
-                error
-            );
+    #[cfg(feature = "pdf")]
+    {
+        let result_pdf = extract_bytes(empty_data, "application/pdf", &config).await;
+        match result_pdf {
+            Ok(extraction) => {
+                assert!(
+                    extraction.content.is_empty(),
+                    "Empty PDF should have empty content if it succeeds"
+                );
+                assert!(extraction.chunks.is_none(), "Chunks should be None");
+            }
+            Err(error) => {
+                assert!(
+                    matches!(
+                        error,
+                        kreuzberg::KreuzbergError::Parsing { .. } | kreuzberg::KreuzbergError::Validation { .. }
+                    ),
+                    "Empty PDF should produce Parsing or Validation error, got: {:?}",
+                    error
+                );
+            }
         }
     }
 
@@ -149,20 +154,24 @@ async fn test_empty_file() {
         }
     }
 
-    match result_xml {
-        Ok(extraction) => {
-            assert!(
-                extraction.content.is_empty(),
-                "Empty XML should have empty content if it succeeds"
-            );
-            assert!(extraction.chunks.is_none(), "Chunks should be None");
-        }
-        Err(error) => {
-            assert!(
-                matches!(error, kreuzberg::KreuzbergError::Parsing { .. }),
-                "Empty XML error should be Parsing type, got: {:?}",
-                error
-            );
+    #[cfg(feature = "xml")]
+    {
+        let result_xml = extract_bytes(empty_data, "application/xml", &config).await;
+        match result_xml {
+            Ok(extraction) => {
+                assert!(
+                    extraction.content.is_empty(),
+                    "Empty XML should have empty content if it succeeds"
+                );
+                assert!(extraction.chunks.is_none(), "Chunks should be None");
+            }
+            Err(error) => {
+                assert!(
+                    matches!(error, kreuzberg::KreuzbergError::Parsing { .. }),
+                    "Empty XML error should be Parsing type, got: {:?}",
+                    error
+                );
+            }
         }
     }
 }

data/vendor/kreuzberg/tests/format_integration.rs

@@ -5,6 +5,8 @@
 //! asynchronous APIs or to graceful handling when optional system
 //! dependencies are missing.
 
+#![cfg(any(feature = "pdf", feature = "office", feature = "ocr"))]
+
 mod helpers;
 
 use helpers::{assert_mime_type, assert_non_empty_content, get_test_file_path, test_documents_available};

data/vendor/kreuzberg/tests/image_integration.rs

@@ -11,6 +11,8 @@
 //! - Test OCR with various languages and layouts
 //! - Verify graceful handling of images without text
 
+#![cfg(feature = "ocr")]
+
 mod helpers;
 
 use helpers::*;

data/vendor/kreuzberg/tests/mime_detection.rs

@@ -276,22 +276,23 @@ async fn test_no_extension() {
 
     let detected = detect_mime_type(&temp_path, true);
 
-    if detected.is_err() {
-        let error = detected.unwrap_err();
-        assert!(
-            matches!(
-                error,
-                kreuzberg::KreuzbergError::Validation { .. } | kreuzberg::KreuzbergError::UnsupportedFormat(_)
-            ),
-            "Should return appropriate error for file without extension"
-        );
-    } else {
-        let mime = detected.unwrap();
-        assert!(
-            mime.contains('/'),
-            "Detected MIME type should be valid format: {}",
-            mime
-        );
+    match detected {
+        Err(error) => {
+            assert!(
+                matches!(
+                    error,
+                    kreuzberg::KreuzbergError::Validation { .. } | kreuzberg::KreuzbergError::UnsupportedFormat(_)
+                ),
+                "Should return appropriate error for file without extension"
+            );
+        }
+        Ok(mime) => {
+            assert!(
+                mime.contains('/'),
+                "Detected MIME type should be valid format: {}",
+                mime
+            );
+        }
     }
 
     let _ = std::fs::remove_file(&temp_path);

data/vendor/kreuzberg/tests/ocr_configuration.rs

@@ -11,6 +11,8 @@
 //! - Verify configuration changes actually affect output
 //! - Test table detection with various settings
 
+#![cfg(feature = "ocr")]
+
 mod helpers;
 
 use helpers::*;
@@ -204,6 +206,7 @@ fn test_ocr_psm_single_line() {
 }
 
 #[test]
+#[cfg(feature = "pdf")]
 fn test_force_ocr_on_text_pdf() {
     if skip_if_missing("pdfs/fake_memo.pdf") {
         return;
@@ -233,6 +236,7 @@ fn test_force_ocr_on_text_pdf() {
 }
 
 #[test]
+#[cfg(feature = "pdf")]
 fn test_force_ocr_disabled() {
     if skip_if_missing("pdfs/fake_memo.pdf") {
         return;

data/vendor/kreuzberg/tests/ocr_errors.rs

@@ -13,6 +13,8 @@
 //! - Test recovery from transient failures
 //! - Validate resource limits and constraints
 
+#![cfg(feature = "ocr")]
+
 mod helpers;
 
 use helpers::*;
@@ -451,6 +453,9 @@ fn test_ocr_cache_disabled_then_enabled() {
     };
 
     let result1 = extract_file_sync(&file_path, None, &config_no_cache);
+    if matches!(result1, Err(KreuzbergError::MissingDependency(_))) {
+        return;
+    }
     assert!(result1.is_ok(), "First extraction should succeed");
 
     let config_with_cache = ExtractionConfig {
@@ -468,6 +473,9 @@ fn test_ocr_cache_disabled_then_enabled() {
     };
 
     let result2 = extract_file_sync(&file_path, None, &config_with_cache);
+    if matches!(result2, Err(KreuzbergError::MissingDependency(_))) {
+        return;
+    }
     assert!(result2.is_ok(), "Second extraction should succeed");
 
     assert_non_empty_content(&result1.unwrap());
@@ -495,6 +503,13 @@ fn test_ocr_concurrent_same_file() {
         ..Default::default()
     });
 
+    if matches!(
+        extract_file_sync(&*file_path, None, &config),
+        Err(KreuzbergError::MissingDependency(_))
+    ) {
+        return;
+    }
+
     let mut handles = vec![];
     for i in 0..5 {
         let file_path_clone = Arc::clone(&file_path);
@@ -554,6 +569,13 @@ fn test_ocr_concurrent_different_files() {
         ..Default::default()
     });
 
+    if matches!(
+        extract_file_sync(&files[0], None, &config),
+        Err(KreuzbergError::MissingDependency(_))
+    ) {
+        return;
+    }
+
     let mut handles = vec![];
     for (i, file_path) in files.iter().enumerate() {
         let file_path_clone = file_path.clone();

data/vendor/kreuzberg/tests/ocr_quality.rs

@@ -14,6 +14,8 @@
 //! - Verify layout preservation (line counts, structure)
 //! - Assert minimum quality thresholds
 
+#![cfg(all(feature = "ocr", feature = "pdf"))]
+
 mod helpers;
 
 use helpers::*;

data/vendor/kreuzberg/tests/odt_extractor_tests.rs

@@ -69,16 +69,13 @@ async fn test_odt_metadata_extraction() {
         "Should contain document title in content"
     );
 
-    // Verify metadata extraction
     let metadata = &result.metadata.additional;
     println!("Extracted metadata: {:?}", metadata);
 
-    // Check title
     if let Some(title) = metadata.get("title") {
         assert_eq!(title.as_str(), Some("Test Metadata Document"), "Title should match");
     }
 
-    // Check subject
     if let Some(subject) = metadata.get("subject") {
         assert_eq!(
             subject.as_str(),
@@ -87,28 +84,23 @@ async fn test_odt_metadata_extraction() {
         );
     }
 
-    // Check creator/author
     if let Some(created_by) = metadata.get("created_by") {
         assert_eq!(created_by.as_str(), Some("John Doe"), "Creator should match");
     }
 
-    // Check authors array
     if let Some(authors) = metadata.get("authors") {
         let authors_array = authors.as_array().expect("Authors should be an array");
         assert_eq!(authors_array.len(), 1, "Should have one author");
         assert_eq!(authors_array[0].as_str(), Some("John Doe"), "Author name should match");
     }
 
-    // Check creation date (should exist)
     assert!(metadata.get("created_at").is_some(), "Creation date should be present");
 
-    // Check modification date (should exist)
     assert!(
         metadata.get("modified_at").is_some(),
         "Modification date should be present"
     );
 
-    // Check generator
     if let Some(generator) = metadata.get("generator") {
         let gen_str = generator.as_str().expect("Generator should be a string");
         assert!(gen_str.contains("Pandoc"), "Generator should be Pandoc");
@@ -604,18 +596,11 @@ async fn test_odt_table_no_duplicate_content() {
 
     assert!(!result.content.is_empty(), "Content should not be empty");
 
-    // Count how many times we see "Content" in the output
-    // In a properly fixed version, it should appear only once in the markdown table
-    // or possibly twice if headers appear with the same name, but not multiple times
-    // for the same cell
     let content_count = result.content.matches("Content").count();
 
-    // "Content" appears twice in the header "More content" in a simple table
-    // It should not appear more than 3 times (once in header, once in data cell, once in a different word like "More content")
     println!("   'Content' appears {} times in output", content_count);
     println!("   Content preview:\n{}", result.content);
 
-    // This verifies that we're not getting duplicate cell content extracted
     assert!(
         content_count <= 3,
         "Content should not appear excessively, indicating no duplicate table cell extraction"
@@ -628,7 +613,6 @@ async fn test_odt_table_no_duplicate_content() {
 /// Uses the extraction_test document created with pandoc to ensure complete content
 #[tokio::test]
 async fn test_odt_comprehensive_table_extraction() {
-    // This test uses the pandoc-generated test document
     let test_file = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
         .parent()
         .unwrap()
@@ -648,7 +632,6 @@ async fn test_odt_comprehensive_table_extraction() {
 
     assert!(!result.content.is_empty(), "Content should not be empty");
 
-    // Verify all sections are present
     assert!(result.content.contains("Comprehensive"), "Should contain heading");
     assert!(
         result.content.contains("First Section") || result.content.contains("First"),
@@ -663,14 +646,12 @@ async fn test_odt_comprehensive_table_extraction() {
         "Should contain third section"
     );
 
-    // Verify tables are present and formatted correctly (as markdown)
     assert!(
         result.content.contains("|"),
         "Should contain pipe characters for markdown tables"
     );
     assert!(result.content.contains("---"), "Should contain table separator");
 
-    // Verify table content is extracted
     assert!(
         result.content.contains("Header 1") || result.content.contains("Cell 1A"),
         "Should contain table data"
@@ -680,8 +661,6 @@ async fn test_odt_comprehensive_table_extraction() {
         "Should contain second table data"
     );
 
-    // Verify no excessive duplication of cells (a simple heuristic check)
-    // Count "Cell 1A" - should appear once or twice at most
     let cell_count = result.content.matches("Cell 1A").count();
     assert!(
         cell_count <= 2,

data/vendor/kreuzberg/tests/pdf_integration.rs

@@ -4,6 +4,8 @@
 //! multi-language E2E generator. This module keeps only the cases that
 //! exercise Rust-specific failure handling or error propagation.
 
+#![cfg(feature = "pdf")]
+
 mod helpers;
 
 use helpers::*;