kreuzberg 4.0.0.pre.rc.14 → 4.0.0.pre.rc.15

data/vendor/kreuzberg-ffi/tests.disabled/config_tests.rs

@@ -1,346 +0,0 @@
-use std::ffi::{CStr, CString};
-use std::fs;
-use std::os::raw::c_char;
-use std::ptr;
-use tempfile::TempDir;
-
-unsafe extern "C" {
-    fn kreuzberg_config_from_file(path: *const c_char) -> *mut std::ffi::c_void;
-
-    fn kreuzberg_config_discover() -> *mut std::ffi::c_void;
-
-    fn kreuzberg_last_error() -> *const c_char;
-
-    fn kreuzberg_free_config(config: *mut std::ffi::c_void);
-}
-
-#[test]
-fn test_config_from_file_toml() {
-    unsafe {
-        let temp_dir = TempDir::new().unwrap();
-        let config_path = temp_dir.path().join("kreuzberg.toml");
-
-        let config_content = r#"
-[ocr]
-enabled = true
-backend = "tesseract"
-
-[chunking]
-enabled = false
-        "#;
-
-        fs::write(&config_path, config_content).unwrap();
-
-        let path_str = CString::new(config_path.to_str().unwrap()).unwrap();
-        let config_ptr = kreuzberg_config_from_file(path_str.as_ptr());
-
-        assert!(!config_ptr.is_null(), "Config should be loaded successfully");
-
-        kreuzberg_free_config(config_ptr);
-    }
-}
-
-#[test]
-fn test_config_from_file_yaml() {
-    unsafe {
-        let temp_dir = TempDir::new().unwrap();
-        let config_path = temp_dir.path().join("kreuzberg.yaml");
-
-        let config_content = r#"
-ocr:
-  enabled: true
-  backend: tesseract
-
-chunking:
-  enabled: false
-        "#;
-
-        fs::write(&config_path, config_content).unwrap();
-
-        let path_str = CString::new(config_path.to_str().unwrap()).unwrap();
-        let config_ptr = kreuzberg_config_from_file(path_str.as_ptr());
-
-        assert!(!config_ptr.is_null(), "Config should be loaded successfully");
-
-        kreuzberg_free_config(config_ptr);
-    }
-}
-
-#[test]
-fn test_config_from_file_json() {
-    unsafe {
-        let temp_dir = TempDir::new().unwrap();
-        let config_path = temp_dir.path().join("kreuzberg.json");
-
-        let config_content = r#"
-{
-  "ocr": {
-    "enabled": true,
-    "backend": "tesseract"
-  },
-  "chunking": {
-    "enabled": false
-  }
-}
-        "#;
-
-        fs::write(&config_path, config_content).unwrap();
-
-        let path_str = CString::new(config_path.to_str().unwrap()).unwrap();
-        let config_ptr = kreuzberg_config_from_file(path_str.as_ptr());
-
-        assert!(!config_ptr.is_null(), "Config should be loaded successfully");
-
-        kreuzberg_free_config(config_ptr);
-    }
-}
-
-#[test]
-fn test_config_from_file_null_path() {
-    unsafe {
-        let config_ptr = kreuzberg_config_from_file(ptr::null());
-
-        assert!(config_ptr.is_null(), "Should return NULL for NULL path");
-
-        let error = kreuzberg_last_error();
-        assert!(!error.is_null());
-        let error_str = CStr::from_ptr(error).to_str().unwrap();
-        assert!(error_str.contains("NULL"), "Error should mention NULL: {}", error_str);
-    }
-}
-
-#[test]
-fn test_config_from_file_nonexistent() {
-    unsafe {
-        let path = CString::new("/nonexistent/path/kreuzberg.toml").unwrap();
-        let config_ptr = kreuzberg_config_from_file(path.as_ptr());
-
-        assert!(config_ptr.is_null(), "Should return NULL for nonexistent file");
-
-        let error = kreuzberg_last_error();
-        assert!(!error.is_null());
-        let error_str = CStr::from_ptr(error).to_str().unwrap();
-        assert!(
-            error_str.contains("IO") || error_str.contains("not found") || error_str.contains("No such"),
-            "Error should indicate file not found: {}",
-            error_str
-        );
-    }
-}
-
-#[test]
-fn test_config_from_file_invalid_toml() {
-    unsafe {
-        let temp_dir = TempDir::new().unwrap();
-        let config_path = temp_dir.path().join("invalid.toml");
-
-        let config_content = r#"
-[ocr
-enabled = true  # Missing closing bracket
-        "#;
-
-        fs::write(&config_path, config_content).unwrap();
-
-        let path_str = CString::new(config_path.to_str().unwrap()).unwrap();
-        let config_ptr = kreuzberg_config_from_file(path_str.as_ptr());
-
-        assert!(config_ptr.is_null(), "Should return NULL for invalid TOML");
-
-        let error = kreuzberg_last_error();
-        assert!(!error.is_null());
-    }
-}
-
-#[test]
-fn test_config_from_file_invalid_json() {
-    unsafe {
-        let temp_dir = TempDir::new().unwrap();
-        let config_path = temp_dir.path().join("invalid.json");
-
-        let config_content = r#"
-{
-  "ocr": {
-    "enabled": true,
-  }  // Trailing comma is invalid in strict JSON
-}
-        "#;
-
-        fs::write(&config_path, config_content).unwrap();
-
-        let path_str = CString::new(config_path.to_str().unwrap()).unwrap();
-        let config_ptr = kreuzberg_config_from_file(path_str.as_ptr());
-
-        assert!(config_ptr.is_null(), "Should return NULL for invalid JSON");
-
-        let error = kreuzberg_last_error();
-        assert!(!error.is_null());
-    }
-}
-
-#[test]
-fn test_config_from_file_no_extension() {
-    unsafe {
-        let temp_dir = TempDir::new().unwrap();
-        let config_path = temp_dir.path().join("kreuzberg");
-
-        fs::write(&config_path, "some content").unwrap();
-
-        let path_str = CString::new(config_path.to_str().unwrap()).unwrap();
-        let config_ptr = kreuzberg_config_from_file(path_str.as_ptr());
-
-        assert!(config_ptr.is_null(), "Should return NULL for file without extension");
-
-        let error = kreuzberg_last_error();
-        assert!(!error.is_null());
-        let error_str = CStr::from_ptr(error).to_str().unwrap();
-        assert!(
-            error_str.contains("extension") || error_str.contains("format"),
-            "Error should mention extension: {}",
-            error_str
-        );
-    }
-}
-
-#[test]
-fn test_config_from_file_invalid_utf8_path() {
-    unsafe {
-        let invalid_path = b"/tmp/test\xFF\xFEinvalid.toml\0";
-
-        let config_ptr = kreuzberg_config_from_file(invalid_path.as_ptr() as *const c_char);
-
-        assert!(config_ptr.is_null(), "Should return NULL for invalid UTF-8 path");
-
-        let error = kreuzberg_last_error();
-        assert!(!error.is_null());
-        let error_str = CStr::from_ptr(error).to_str().unwrap();
-        assert!(error_str.contains("UTF-8"));
-    }
-}
-
-#[test]
-fn test_config_discover_not_found() {
-    unsafe {
-        let temp_dir = TempDir::new().unwrap();
-        let original_dir = std::env::current_dir().unwrap();
-
-        std::env::set_current_dir(&temp_dir).unwrap();
-
-        let config_ptr = kreuzberg_config_discover();
-
-        assert!(config_ptr.is_null(), "Should return NULL when no config found");
-
-        let error = kreuzberg_last_error();
-        if !error.is_null() {
-            let error_str = CStr::from_ptr(error).to_str().unwrap();
-            assert!(
-                error_str.is_empty() || error_str.contains("not found") || error_str.contains("IO"),
-                "Error should be empty or indicate not found: {}",
-                error_str
-            );
-        }
-
-        std::env::set_current_dir(original_dir).unwrap();
-    }
-}
-
-#[test]
-fn test_config_discover_toml() {
-    unsafe {
-        let temp_dir = TempDir::new().unwrap();
-        let config_path = temp_dir.path().join("kreuzberg.toml");
-
-        let config_content = r#"
-[ocr]
-enabled = true
-        "#;
-
-        fs::write(&config_path, config_content).unwrap();
-
-        let original_dir = std::env::current_dir().unwrap();
-        std::env::set_current_dir(&temp_dir).unwrap();
-
-        let config_ptr = kreuzberg_config_discover();
-
-        assert!(!config_ptr.is_null(), "Should discover config in current directory");
-
-        kreuzberg_free_config(config_ptr);
-
-        std::env::set_current_dir(original_dir).unwrap();
-    }
-}
-
-#[test]
-fn test_config_discover_yaml() {
-    unsafe {
-        let temp_dir = TempDir::new().unwrap();
-        let config_path = temp_dir.path().join("kreuzberg.yaml");
-
-        let config_content = r#"
-ocr:
-  enabled: true
-        "#;
-
-        fs::write(&config_path, config_content).unwrap();
-
-        let original_dir = std::env::current_dir().unwrap();
-        std::env::set_current_dir(&temp_dir).unwrap();
-
-        let config_ptr = kreuzberg_config_discover();
-
-        assert!(!config_ptr.is_null(), "Should discover YAML config");
-
-        kreuzberg_free_config(config_ptr);
-
-        std::env::set_current_dir(original_dir).unwrap();
-    }
-}
-
-#[test]
-fn test_config_discover_parent_directory() {
-    unsafe {
-        let temp_dir = TempDir::new().unwrap();
-        let config_path = temp_dir.path().join("kreuzberg.toml");
-
-        let config_content = r#"
-[ocr]
-enabled = true
-        "#;
-
-        fs::write(&config_path, config_content).unwrap();
-
-        let subdir = temp_dir.path().join("subdir");
-        fs::create_dir(&subdir).unwrap();
-
-        let original_dir = std::env::current_dir().unwrap();
-        std::env::set_current_dir(&subdir).unwrap();
-
-        let config_ptr = kreuzberg_config_discover();
-
-        assert!(!config_ptr.is_null(), "Should discover config in parent directory");
-
-        kreuzberg_free_config(config_ptr);
-
-        std::env::set_current_dir(original_dir).unwrap();
-    }
-}
-
-#[test]
-fn test_config_discover_preference_order() {
-    unsafe {
-        let temp_dir = TempDir::new().unwrap();
-
-        fs::write(temp_dir.path().join("kreuzberg.toml"), "[ocr]\nenabled = true").unwrap();
-        fs::write(temp_dir.path().join("kreuzberg.yaml"), "ocr:\n  enabled: false").unwrap();
-
-        let original_dir = std::env::current_dir().unwrap();
-        std::env::set_current_dir(&temp_dir).unwrap();
-
-        let config_ptr = kreuzberg_config_discover();
-
-        assert!(!config_ptr.is_null(), "Should discover a config file");
-
-        kreuzberg_free_config(config_ptr);
-
-        std::env::set_current_dir(original_dir).unwrap();
-    }
-}

data/vendor/kreuzberg-ffi/tests.disabled/extractor_tests.rs

@@ -1,232 +0,0 @@
-use std::ffi::{CStr, CString};
-use std::os::raw::c_char;
-use std::ptr;
-
-unsafe extern "C" {
-    fn kreuzberg_register_document_extractor(
-        name: *const c_char,
-        callback: unsafe extern "C" fn(*const u8, usize, *const c_char, *const c_char) -> *mut c_char,
-        mime_types: *const c_char,
-        priority: i32,
-    ) -> bool;
-
-    fn kreuzberg_unregister_document_extractor(name: *const c_char) -> bool;
-
-    fn kreuzberg_list_document_extractors() -> *mut c_char;
-
-    fn kreuzberg_last_error() -> *const c_char;
-
-    fn kreuzberg_free_string(s: *mut c_char);
-}
-
-unsafe extern "C" fn test_extractor_callback(
-    _content: *const u8,
-    _content_len: usize,
-    _mime_type: *const c_char,
-    _config_json: *const c_char,
-) -> *mut c_char {
-    let result = r#"{
-        "content": "test extracted content",
-        "mime_type": "text/plain",
-        "metadata": {}
-    }"#;
-    CString::new(result).unwrap().into_raw()
-}
-
-#[allow(dead_code)]
-unsafe extern "C" fn failing_extractor_callback(
-    _content: *const u8,
-    _content_len: usize,
-    _mime_type: *const c_char,
-    _config_json: *const c_char,
-) -> *mut c_char {
-    ptr::null_mut()
-}
-
-#[test]
-fn test_register_document_extractor_success() {
-    unsafe {
-        let name = CString::new("test-extractor").unwrap();
-        let mime_types = CString::new("application/x-test,text/x-test").unwrap();
-
-        let success =
-            kreuzberg_register_document_extractor(name.as_ptr(), test_extractor_callback, mime_types.as_ptr(), 100);
-
-        assert!(success, "Failed to register extractor");
-
-        kreuzberg_unregister_document_extractor(name.as_ptr());
-    }
-}
-
-#[test]
-fn test_register_document_extractor_null_name() {
-    unsafe {
-        let mime_types = CString::new("application/x-test").unwrap();
-
-        let success =
-            kreuzberg_register_document_extractor(ptr::null(), test_extractor_callback, mime_types.as_ptr(), 100);
-
-        assert!(!success, "Should fail with NULL name");
-
-        let error = kreuzberg_last_error();
-        assert!(!error.is_null());
-        let error_str = CStr::from_ptr(error).to_str().unwrap();
-        assert!(error_str.contains("NULL"), "Error should mention NULL: {}", error_str);
-    }
-}
-
-#[test]
-fn test_register_document_extractor_null_mime_types() {
-    unsafe {
-        let name = CString::new("test-extractor").unwrap();
-
-        let success = kreuzberg_register_document_extractor(name.as_ptr(), test_extractor_callback, ptr::null(), 100);
-
-        assert!(!success, "Should fail with NULL MIME types");
-
-        let error = kreuzberg_last_error();
-        assert!(!error.is_null());
-        let error_str = CStr::from_ptr(error).to_str().unwrap();
-        assert!(error_str.contains("MIME") || error_str.contains("NULL"));
-    }
-}
-
-#[test]
-fn test_register_document_extractor_empty_mime_types() {
-    unsafe {
-        let name = CString::new("test-extractor").unwrap();
-        let mime_types = CString::new("").unwrap();
-
-        let success =
-            kreuzberg_register_document_extractor(name.as_ptr(), test_extractor_callback, mime_types.as_ptr(), 100);
-
-        assert!(!success, "Should fail with empty MIME types");
-
-        let error = kreuzberg_last_error();
-        assert!(!error.is_null());
-        let error_str = CStr::from_ptr(error).to_str().unwrap();
-        assert!(error_str.contains("MIME"));
-    }
-}
-
-#[test]
-fn test_unregister_document_extractor_success() {
-    unsafe {
-        let name = CString::new("test-extractor-unregister").unwrap();
-        let mime_types = CString::new("application/x-test").unwrap();
-
-        let success =
-            kreuzberg_register_document_extractor(name.as_ptr(), test_extractor_callback, mime_types.as_ptr(), 100);
-        assert!(success);
-
-        let success = kreuzberg_unregister_document_extractor(name.as_ptr());
-        assert!(success, "Failed to unregister extractor");
-    }
-}
-
-#[test]
-fn test_unregister_document_extractor_null_name() {
-    unsafe {
-        let success = kreuzberg_unregister_document_extractor(ptr::null());
-        assert!(!success, "Should fail with NULL name");
-
-        let error = kreuzberg_last_error();
-        assert!(!error.is_null());
-        let error_str = CStr::from_ptr(error).to_str().unwrap();
-        assert!(error_str.contains("NULL"));
-    }
-}
-
-#[test]
-fn test_unregister_nonexistent_extractor() {
-    unsafe {
-        let name = CString::new("nonexistent-extractor").unwrap();
-
-        let success = kreuzberg_unregister_document_extractor(name.as_ptr());
-        assert!(success, "Unregistering nonexistent extractor should succeed");
-    }
-}
-
-#[test]
-fn test_list_document_extractors() {
-    unsafe {
-        let name1 = CString::new("test-extractor-1").unwrap();
-        let name2 = CString::new("test-extractor-2").unwrap();
-        let mime_types = CString::new("application/x-test").unwrap();
-
-        kreuzberg_register_document_extractor(name1.as_ptr(), test_extractor_callback, mime_types.as_ptr(), 100);
-        kreuzberg_register_document_extractor(name2.as_ptr(), test_extractor_callback, mime_types.as_ptr(), 100);
-
-        let list_ptr = kreuzberg_list_document_extractors();
-        assert!(!list_ptr.is_null(), "List should not be NULL");
-
-        let list_str = CStr::from_ptr(list_ptr).to_str().unwrap();
-        assert!(list_str.contains("test-extractor-1"));
-        assert!(list_str.contains("test-extractor-2"));
-
-        kreuzberg_free_string(list_ptr);
-
-        kreuzberg_unregister_document_extractor(name1.as_ptr());
-        kreuzberg_unregister_document_extractor(name2.as_ptr());
-    }
-}
-
-#[test]
-fn test_register_multiple_mime_types() {
-    unsafe {
-        let name = CString::new("multi-mime-extractor").unwrap();
-        let mime_types = CString::new("application/x-test1, text/x-test2 , image/x-test3").unwrap();
-
-        let success =
-            kreuzberg_register_document_extractor(name.as_ptr(), test_extractor_callback, mime_types.as_ptr(), 100);
-
-        assert!(success, "Failed to register with multiple MIME types");
-
-        kreuzberg_unregister_document_extractor(name.as_ptr());
-    }
-}
-
-#[test]
-fn test_register_with_different_priorities() {
-    unsafe {
-        let name_high = CString::new("high-priority-extractor").unwrap();
-        let name_low = CString::new("low-priority-extractor").unwrap();
-        let mime_types = CString::new("application/x-test").unwrap();
-
-        let success1 = kreuzberg_register_document_extractor(
-            name_high.as_ptr(),
-            test_extractor_callback,
-            mime_types.as_ptr(),
-            200,
-        );
-        let success2 =
-            kreuzberg_register_document_extractor(name_low.as_ptr(), test_extractor_callback, mime_types.as_ptr(), 50);
-
-        assert!(success1 && success2, "Failed to register extractors");
-
-        kreuzberg_unregister_document_extractor(name_high.as_ptr());
-        kreuzberg_unregister_document_extractor(name_low.as_ptr());
-    }
-}
-
-#[test]
-fn test_invalid_utf8_name() {
-    unsafe {
-        let invalid_name = b"test\xFF\xFEinvalid\0";
-        let mime_types = CString::new("application/x-test").unwrap();
-
-        let success = kreuzberg_register_document_extractor(
-            invalid_name.as_ptr() as *const c_char,
-            test_extractor_callback,
-            mime_types.as_ptr(),
-            100,
-        );
-
-        assert!(!success, "Should fail with invalid UTF-8 name");
-
-        let error = kreuzberg_last_error();
-        assert!(!error.is_null());
-        let error_str = CStr::from_ptr(error).to_str().unwrap();
-        assert!(error_str.contains("UTF-8"));
-    }
-}