kreuzberg 4.0.0.pre.rc.6

data/vendor/kreuzberg/tests/epub_native_extractor_tests.rs

@@ -0,0 +1,275 @@
+//! Integration tests for the native EPUB extractor
+//!
+//! These tests validate the native Rust EPUB extractor (EpubExtractor)
+//! which uses zip + roxmltree + html-to-markdown-rs (permissive licenses).
+//!
+//! This test suite verifies the fix for the two-pass OPF parsing bug that
+//! caused 99.84% content loss due to single-pass manifest/spine resolution.
+
+#![cfg(feature = "office")]
+
+use kreuzberg::core::config::ExtractionConfig;
+use kreuzberg::extractors::EpubExtractor;
+use kreuzberg::plugins::DocumentExtractor;
+use std::path::PathBuf;
+
+/// Helper to resolve workspace root and construct test file paths
+fn get_test_epub_path(filename: &str) -> PathBuf {
+    let workspace_root = std::path::Path::new(env!("CARGO_MANIFEST_DIR"))
+        .parent()
+        .unwrap()
+        .parent()
+        .unwrap();
+    workspace_root.join(format!("test_documents/epub/{}", filename))
+}
+
+/// Test 1: Basic EPUB extraction - wasteland.epub
+///
+/// Validates:
+/// - Two-pass OPF parsing works correctly
+/// - Manifest is fully populated before spine resolution
+/// - Content is extracted successfully (>2000 bytes expected)
+/// - Metadata is extracted correctly
+#[tokio::test]
+async fn test_native_epub_wasteland_extraction() {
+    let test_file = get_test_epub_path("wasteland.epub");
+    if !test_file.exists() {
+        println!("Skipping test: Test file not found at {:?}", test_file);
+        return;
+    }
+
+    let bytes = std::fs::read(&test_file).expect("Failed to read wasteland.epub");
+    let extractor = EpubExtractor::new();
+    let config = ExtractionConfig::default();
+
+    let result = extractor
+        .extract_bytes(&bytes, "application/epub+zip", &config)
+        .await
+        .expect("Should extract wasteland.epub successfully");
+
+    assert!(
+        result.content.len() > 2000,
+        "Should extract substantial content from Wasteland, got {} bytes",
+        result.content.len()
+    );
+
+    assert!(
+        result.metadata.additional.contains_key("title"),
+        "Should extract title metadata"
+    );
+    assert_eq!(
+        result.metadata.additional.get("title").and_then(|v| v.as_str()),
+        Some("The Waste Land"),
+        "Should have correct title"
+    );
+
+    assert!(
+        result.metadata.additional.contains_key("creator"),
+        "Should extract creator metadata"
+    );
+
+    assert!(
+        result.content.contains("April") || result.content.contains("cruellest"),
+        "Should contain key phrases from The Waste Land"
+    );
+
+    println!("✅ Wasteland extraction test passed ({} bytes)", result.content.len());
+}
+
+/// Test 2: EPUB with images - img.epub
+///
+/// Validates:
+/// - EPUB with embedded images extracts successfully
+/// - Text content is extracted (images are in manifest but not in content)
+/// - Metadata is extracted
+#[tokio::test]
+async fn test_native_epub_images_extraction() {
+    let test_file = get_test_epub_path("img.epub");
+    if !test_file.exists() {
+        println!("Skipping test: Test file not found at {:?}", test_file);
+        return;
+    }
+
+    let bytes = std::fs::read(&test_file).expect("Failed to read img.epub");
+    let extractor = EpubExtractor::new();
+    let config = ExtractionConfig::default();
+
+    let result = extractor
+        .extract_bytes(&bytes, "application/epub+zip", &config)
+        .await
+        .expect("Should extract img.epub successfully");
+
+    assert!(
+        result.content.len() > 50,
+        "Should extract text content from EPUB with images, got {} bytes",
+        result.content.len()
+    );
+
+    assert!(
+        result.metadata.additional.contains_key("title"),
+        "Should extract title metadata"
+    );
+
+    println!("✅ Images EPUB extraction test passed ({} bytes)", result.content.len());
+}
+
+/// Test 3: Features EPUB - features.epub
+///
+/// Validates:
+/// - Complex EPUB3 features document extracts successfully
+/// - Multiple chapters/sections are extracted (not just first)
+/// - Substantial content is present (>1000 bytes)
+#[tokio::test]
+async fn test_native_epub_features_extraction() {
+    let test_file = get_test_epub_path("features.epub");
+    if !test_file.exists() {
+        println!("Skipping test: Test file not found at {:?}", test_file);
+        return;
+    }
+
+    let bytes = std::fs::read(&test_file).expect("Failed to read features.epub");
+    let extractor = EpubExtractor::new();
+    let config = ExtractionConfig::default();
+
+    let result = extractor
+        .extract_bytes(&bytes, "application/epub+zip", &config)
+        .await
+        .expect("Should extract features.epub successfully");
+
+    assert!(
+        result.content.len() > 1000,
+        "CRITICAL: Should extract from ALL chapters, got only {} bytes. \
+         This indicates the two-pass bug is not fixed!",
+        result.content.len()
+    );
+
+    println!(
+        "✅ Features EPUB extraction test passed ({} bytes)",
+        result.content.len()
+    );
+}
+
+/// Test 4: EPUB2 with cover - epub2_cover.epub
+///
+/// Validates:
+/// - EPUB2 format is supported
+/// - Cover handling works correctly
+/// - Content and metadata extracted
+#[tokio::test]
+async fn test_native_epub2_cover_extraction() {
+    let test_file = get_test_epub_path("epub2_cover.epub");
+    if !test_file.exists() {
+        println!("Skipping test: Test file not found at {:?}", test_file);
+        return;
+    }
+
+    let bytes = std::fs::read(&test_file).expect("Failed to read epub2_cover.epub");
+    let extractor = EpubExtractor::new();
+    let config = ExtractionConfig::default();
+
+    let result = extractor
+        .extract_bytes(&bytes, "application/epub+zip", &config)
+        .await
+        .expect("Should extract epub2_cover.epub successfully");
+
+    assert!(
+        result.content.len() > 50,
+        "Should extract content from EPUB2 with cover, got {} bytes",
+        result.content.len()
+    );
+
+    assert_eq!(
+        result.metadata.additional.get("title").and_then(|v| v.as_str()),
+        Some("Pandoc EPUB Test"),
+        "Should have correct title"
+    );
+
+    println!("✅ EPUB2 cover extraction test passed ({} bytes)", result.content.len());
+}
+
+/// Test 5: Deterministic extraction
+///
+/// Validates:
+/// - Same input produces same output (no randomness)
+/// - Extraction is stable and reproducible
+#[tokio::test]
+async fn test_native_epub_deterministic_extraction() {
+    let test_file = get_test_epub_path("features.epub");
+    if !test_file.exists() {
+        println!("Skipping test: Test file not found at {:?}", test_file);
+        return;
+    }
+
+    let bytes = std::fs::read(&test_file).expect("Failed to read features.epub");
+    let extractor = EpubExtractor::new();
+    let config = ExtractionConfig::default();
+
+    let result1 = extractor
+        .extract_bytes(&bytes, "application/epub+zip", &config)
+        .await
+        .expect("First extraction should succeed");
+
+    let result2 = extractor
+        .extract_bytes(&bytes, "application/epub+zip", &config)
+        .await
+        .expect("Second extraction should succeed");
+
+    assert_eq!(
+        result1.content, result2.content,
+        "Extraction should be deterministic - same input should produce same output"
+    );
+
+    assert_eq!(
+        result1.metadata.additional, result2.metadata.additional,
+        "Metadata extraction should be deterministic"
+    );
+
+    println!("✅ Deterministic extraction test passed");
+}
+
+/// Test 6: No content loss across multiple EPUBs
+///
+/// Validates:
+/// - All test EPUB files extract successfully
+/// - No file has empty or nearly-empty content
+/// - Bug causing 99.84% content loss is fixed
+#[tokio::test]
+async fn test_native_epub_no_content_loss() {
+    let epub_files = vec![
+        ("epub2_cover.epub", 50),
+        ("epub2_no_cover.epub", 50),
+        ("img.epub", 50),
+        ("features.epub", 1000),
+        ("wasteland.epub", 2000),
+    ];
+
+    let extractor = EpubExtractor::new();
+    let config = ExtractionConfig::default();
+
+    for (epub_file, min_bytes) in epub_files {
+        let test_file = get_test_epub_path(epub_file);
+        if !test_file.exists() {
+            println!("⚠ Skipping {}: not found", epub_file);
+            continue;
+        }
+
+        let bytes = std::fs::read(&test_file).unwrap_or_else(|_| panic!("Failed to read {}", epub_file));
+
+        let result = extractor
+            .extract_bytes(&bytes, "application/epub+zip", &config)
+            .await
+            .unwrap_or_else(|_| panic!("Should extract {}", epub_file));
+
+        assert!(
+            result.content.len() >= min_bytes,
+            "CRITICAL: {} extracted only {} bytes (expected >= {}). Content loss bug?",
+            epub_file,
+            result.content.len(),
+            min_bytes
+        );
+
+        println!("✓ {} - {} bytes extracted", epub_file, result.content.len());
+    }
+
+    println!("✅ All EPUBs extracted successfully - no content loss!");
+}

data/vendor/kreuzberg/tests/error_handling.rs

@@ -0,0 +1,393 @@
+//! Error handling and edge case integration tests.
+//!
+//! Tests for corrupted files, edge cases, and invalid inputs.
+//! Validates that the system handles errors gracefully without panics.
+
+use kreuzberg::core::config::ExtractionConfig;
+use kreuzberg::core::extractor::{extract_bytes, extract_file};
+use std::io::Write;
+use tempfile::NamedTempFile;
+
+mod helpers;
+
+/// Test truncated PDF - incomplete PDF file.
+#[tokio::test]
+async fn test_truncated_pdf() {
+    let config = ExtractionConfig::default();
+
+    let truncated_pdf = b"%PDF-1.4\n1 0 obj\n<<";
+
+    let result = extract_bytes(truncated_pdf, "application/pdf", &config).await;
+
+    assert!(result.is_err(), "Truncated PDF should fail gracefully");
+
+    let error = result.unwrap_err();
+    assert!(
+        matches!(error, kreuzberg::KreuzbergError::Parsing { .. }),
+        "Truncated PDF should produce Parsing error, got: {:?}",
+        error
+    );
+}
+
+/// Test corrupted ZIP - malformed archive.
+#[tokio::test]
+async fn test_corrupted_zip() {
+    let config = ExtractionConfig::default();
+
+    let corrupted_zip = vec![0x50, 0x4B, 0x03, 0x04, 0xFF, 0xFF, 0xFF, 0xFF, 0x00, 0x00, 0x00, 0x00];
+
+    let result = extract_bytes(&corrupted_zip, "application/zip", &config).await;
+
+    assert!(result.is_err(), "Corrupted ZIP should fail gracefully");
+
+    let error = result.unwrap_err();
+    assert!(
+        matches!(error, kreuzberg::KreuzbergError::Parsing { .. }),
+        "Corrupted ZIP should produce Parsing error, got: {:?}",
+        error
+    );
+}
+
+/// Test invalid XML - bad XML syntax.
+#[tokio::test]
+async fn test_invalid_xml() {
+    let config = ExtractionConfig::default();
+
+    let invalid_xml = b"<?xml version=\"1.0\"?>\n\
+<root>\n\
+<unclosed>\n\
+<another>text</wrong_tag>\n\
+</root";
+
+    let result = extract_bytes(invalid_xml, "application/xml", &config).await;
+
+    match result {
+        Ok(extraction) => {
+            assert!(
+                extraction.chunks.is_none(),
+                "Chunks should be None without chunking config"
+            );
+        }
+        Err(error) => {
+            assert!(
+                matches!(error, kreuzberg::KreuzbergError::Parsing { .. }),
+                "Invalid XML error should be Parsing type, got: {:?}",
+                error
+            );
+        }
+    }
+}
+
+/// Test corrupted image - invalid image data.
+#[tokio::test]
+async fn test_corrupted_image() {
+    let config = ExtractionConfig::default();
+
+    let corrupted_png = vec![0x89, 0x50, 0x4E, 0x47, 0x0D, 0x0A, 0x1A, 0x0A, 0xFF, 0xFF, 0xFF, 0xFF];
+
+    let result = extract_bytes(&corrupted_png, "image/png", &config).await;
+
+    match result {
+        Ok(extraction) => {
+            assert!(
+                extraction.chunks.is_none(),
+                "Chunks should be None without chunking config"
+            );
+        }
+        Err(error) => {
+            assert!(
+                matches!(error, kreuzberg::KreuzbergError::Parsing { .. })
+                    || matches!(error, kreuzberg::KreuzbergError::Ocr { .. }),
+                "Corrupted image error should be Parsing or OCR type, got: {:?}",
+                error
+            );
+        }
+    }
+}
+
+/// Test empty file - 0 bytes.
+#[tokio::test]
+async fn test_empty_file() {
+    let config = ExtractionConfig::default();
+
+    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
+            );
+        }
+    }
+
+    match result_text {
+        Ok(extraction) => {
+            assert!(
+                extraction.content.is_empty(),
+                "Empty text file should have empty content"
+            );
+            assert!(extraction.chunks.is_none(), "Chunks should be None");
+        }
+        Err(error) => {
+            panic!("Empty text file should not fail, got error: {:?}", error);
+        }
+    }
+
+    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
+            );
+        }
+    }
+}
+
+/// Test very large file - stress test with large content.
+#[tokio::test]
+async fn test_very_large_file() {
+    let config = ExtractionConfig::default();
+
+    let large_text = "This is a line of text that will be repeated many times.\n".repeat(200_000);
+    let large_bytes = large_text.as_bytes();
+
+    let result = extract_bytes(large_bytes, "text/plain", &config).await;
+
+    assert!(result.is_ok(), "Large file should be processed successfully");
+    let extraction = result.unwrap();
+
+    assert!(!extraction.content.is_empty(), "Large file content should not be empty");
+    assert!(extraction.content.len() > 1_000_000, "Content should be large");
+    assert!(
+        extraction.chunks.is_none(),
+        "Chunks should be None without chunking config"
+    );
+    assert!(
+        extraction.detected_languages.is_none(),
+        "Language detection not enabled"
+    );
+    assert!(extraction.tables.is_empty(), "Text file should not have tables");
+
+    assert!(
+        extraction.content.contains("This is a line of text"),
+        "Content should preserve original text"
+    );
+}
+
+/// Test unicode filenames - non-ASCII paths.
+#[tokio::test]
+async fn test_unicode_filenames() {
+    let config = ExtractionConfig::default();
+
+    let mut temp_file = NamedTempFile::new().expect("Should create temp file");
+    temp_file.write_all(b"Test content with Unicode filename.").unwrap();
+
+    let result = extract_file(temp_file.path(), Some("text/plain"), &config).await;
+
+    assert!(result.is_ok(), "Unicode filename should be handled");
+    let extraction = result.unwrap();
+
+    assert!(
+        extraction.content.contains("Test content"),
+        "Content should be extracted"
+    );
+    assert!(
+        extraction.chunks.is_none(),
+        "Chunks should be None without chunking config"
+    );
+    assert!(
+        extraction.detected_languages.is_none(),
+        "Language detection not enabled"
+    );
+}
+
+/// Test special characters in content - emojis, RTL text.
+#[tokio::test]
+async fn test_special_characters_content() {
+    let config = ExtractionConfig::default();
+
+    let special_text = "Emojis: 🎉 🚀 ✅ 🌍\n\
+Arabic (RTL): مرحبا بالعالم\n\
+Chinese: 你好世界\n\
+Japanese: こんにちは世界\n\
+Special chars: © ® ™ € £ ¥\n\
+Math symbols: ∑ ∫ √ ≈ ∞";
+
+    let result = extract_bytes(special_text.as_bytes(), "text/plain", &config).await;
+
+    assert!(result.is_ok(), "Special characters should be handled");
+    let extraction = result.unwrap();
+
+    assert!(!extraction.content.is_empty(), "Content should not be empty");
+    assert!(extraction.content.len() > 10, "Should have substantial content");
+    assert!(
+        extraction.chunks.is_none(),
+        "Chunks should be None without chunking config"
+    );
+    assert!(
+        extraction.detected_languages.is_none(),
+        "Language detection not enabled"
+    );
+
+    assert!(
+        extraction.content.contains("Emojis")
+            || extraction.content.contains("Arabic")
+            || extraction.content.contains("Chinese"),
+        "Should preserve at least some special character text"
+    );
+}
+
+/// Test nonexistent file - file not found.
+#[tokio::test]
+async fn test_nonexistent_file() {
+    let config = ExtractionConfig::default();
+
+    let nonexistent_path = "/nonexistent/path/to/file.pdf";
+
+    let result = extract_file(nonexistent_path, Some("application/pdf"), &config).await;
+
+    assert!(result.is_err(), "Nonexistent file should return error");
+
+    let error = result.unwrap_err();
+    assert!(
+        matches!(error, kreuzberg::KreuzbergError::Io(_))
+            || matches!(error, kreuzberg::KreuzbergError::Validation { .. }),
+        "Should be IO or Validation error for nonexistent file, got: {:?}",
+        error
+    );
+}
+
+/// Test unsupported format - unknown file type.
+#[tokio::test]
+async fn test_unsupported_format() {
+    let config = ExtractionConfig::default();
+
+    let data = b"Some random data";
+
+    let result = extract_bytes(data, "application/x-unknown-format", &config).await;
+
+    assert!(result.is_err(), "Unsupported format should return error");
+
+    let error = result.unwrap_err();
+    assert!(
+        matches!(error, kreuzberg::KreuzbergError::UnsupportedFormat(_)),
+        "Should be UnsupportedFormat error, got: {:?}",
+        error
+    );
+}
+
+/// Test permission denied - no read access (platform-specific).
+#[tokio::test]
+#[cfg(unix)]
+async fn test_permission_denied() {
+    use std::fs;
+    use std::os::unix::fs::PermissionsExt;
+
+    let config = ExtractionConfig::default();
+
+    let mut temp_file = NamedTempFile::new().expect("Should create temp file");
+    temp_file.write_all(b"Test content").unwrap();
+
+    let mut perms = fs::metadata(temp_file.path()).unwrap().permissions();
+    perms.set_mode(0o000);
+    fs::set_permissions(temp_file.path(), perms).unwrap();
+
+    let result = extract_file(temp_file.path(), Some("text/plain"), &config).await;
+
+    let mut perms = fs::metadata(temp_file.path()).unwrap().permissions();
+    perms.set_mode(0o644);
+    fs::set_permissions(temp_file.path(), perms).unwrap();
+
+    assert!(result.is_err(), "Permission denied should return error");
+}
+
+/// Test file extension mismatch - .pdf extension with DOCX content.
+#[tokio::test]
+async fn test_file_extension_mismatch() {
+    let config = ExtractionConfig::default();
+
+    let docx_magic = vec![0x50, 0x4B, 0x03, 0x04, 0x14, 0x00, 0x00, 0x00];
+
+    let result = extract_bytes(&docx_magic, "application/pdf", &config).await;
+
+    assert!(result.is_err(), "MIME type mismatch should fail");
+}
+
+/// Test extraction with null bytes in content.
+#[tokio::test]
+async fn test_null_bytes_in_content() {
+    let config = ExtractionConfig::default();
+
+    let data_with_nulls = b"Text before\x00null\x00bytes\x00after";
+
+    let result = extract_bytes(data_with_nulls, "text/plain", &config).await;
+
+    assert!(result.is_ok(), "Null bytes should be handled");
+    let extraction = result.unwrap();
+
+    assert!(!extraction.content.is_empty(), "Content should not be empty");
+    assert!(
+        extraction.chunks.is_none(),
+        "Chunks should be None without chunking config"
+    );
+
+    assert!(
+        extraction.content.contains("Text before") || extraction.content.contains("after"),
+        "Should preserve at least some of the text content"
+    );
+}
+
+/// Test concurrent extractions of same file.
+#[tokio::test]
+async fn test_concurrent_extractions() {
+    let config = ExtractionConfig::default();
+
+    let text_data = b"Concurrent extraction test content.";
+
+    let handles: Vec<_> = (0..10)
+        .map(|_| {
+            let config = config.clone();
+            tokio::spawn(async move { extract_bytes(text_data, "text/plain", &config).await })
+        })
+        .collect();
+
+    for handle in handles {
+        let result = handle.await.expect("Task should complete");
+        assert!(result.is_ok(), "Concurrent extraction should succeed");
+
+        let extraction = result.unwrap();
+        assert!(
+            extraction.content.contains("Concurrent extraction"),
+            "Content should be extracted correctly"
+        );
+        assert!(extraction.chunks.is_none(), "Chunks should be None");
+        assert!(
+            extraction.detected_languages.is_none(),
+            "Language detection not enabled"
+        );
+    }
+}