kreuzberg 4.0.0.rc2 → 4.0.0

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

@@ -0,0 +1,232 @@
+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"));
+    }
+}

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

@@ -0,0 +1,470 @@
+//! FFI plugin registration integration tests.
+//!
+//! Tests the FFI layer for registering and managing validators and post-processors.
+
+use std::ffi::{CStr, CString};
+use std::os::raw::c_char;
+use std::ptr;
+
+unsafe extern "C" {
+    fn kreuzberg_register_validator(name: *const c_char, callback: ValidatorCallback, priority: i32) -> bool;
+    fn kreuzberg_unregister_validator(name: *const c_char) -> bool;
+    fn kreuzberg_list_validators() -> *mut c_char;
+    fn kreuzberg_clear_validators() -> bool;
+    fn kreuzberg_free_string(s: *mut c_char);
+    fn kreuzberg_last_error() -> *const c_char;
+}
+
+unsafe extern "C" {
+    fn kreuzberg_unregister_ocr_backend(name: *const c_char) -> bool;
+    fn kreuzberg_list_ocr_backends() -> *mut c_char;
+}
+
+type ValidatorCallback = unsafe extern "C" fn(
+    content: *const c_char,
+    mime_type: *const c_char,
+    metadata_json: *const c_char,
+    config_json: *const c_char,
+) -> *mut c_char;
+
+/// Helper to convert *const c_char to String
+unsafe fn c_str_to_string(ptr: *const c_char) -> Option<String> {
+    if ptr.is_null() {
+        None
+    } else {
+        unsafe { Some(CStr::from_ptr(ptr).to_string_lossy().into_owned()) }
+    }
+}
+
+/// Helper to get last error message
+unsafe fn get_last_error() -> Option<String> {
+    let error_ptr = unsafe { kreuzberg_last_error() };
+    unsafe { c_str_to_string(error_ptr) }
+}
+
+/// Mock validator callback that always passes
+unsafe extern "C" fn passing_validator_callback(
+    _content: *const c_char,
+    _mime_type: *const c_char,
+    _metadata_json: *const c_char,
+    _config_json: *const c_char,
+) -> *mut c_char {
+    ptr::null_mut()
+}
+
+/// Mock validator callback that always fails
+unsafe extern "C" fn failing_validator_callback(
+    _content: *const c_char,
+    _mime_type: *const c_char,
+    _metadata_json: *const c_char,
+    _config_json: *const c_char,
+) -> *mut c_char {
+    let error_msg = CString::new("Validation failed: content too short").unwrap();
+    error_msg.into_raw()
+}
+
+/// Test successful validator registration.
+#[test]
+fn test_register_validator_succeeds() {
+    unsafe {
+        kreuzberg_clear_validators();
+
+        let name = CString::new("test-validator").unwrap();
+        let result = kreuzberg_register_validator(name.as_ptr(), passing_validator_callback, 50);
+
+        assert!(result, "Validator registration should succeed");
+
+        let list_ptr = kreuzberg_list_validators();
+        assert!(!list_ptr.is_null(), "List should not be null");
+
+        let list_json = c_str_to_string(list_ptr).expect("Should have valid JSON");
+        kreuzberg_free_string(list_ptr);
+
+        assert!(
+            list_json.contains("test-validator"),
+            "List should contain registered validator"
+        );
+
+        kreuzberg_clear_validators();
+    }
+}
+
+/// Test registering multiple validators.
+#[test]
+fn test_register_multiple_validators_succeeds() {
+    unsafe {
+        kreuzberg_clear_validators();
+
+        let validator1 = CString::new("validator-1").unwrap();
+        let validator2 = CString::new("validator-2").unwrap();
+        let validator3 = CString::new("validator-3").unwrap();
+
+        assert!(
+            kreuzberg_register_validator(validator1.as_ptr(), passing_validator_callback, 100),
+            "First validator registration should succeed"
+        );
+        assert!(
+            kreuzberg_register_validator(validator2.as_ptr(), passing_validator_callback, 50),
+            "Second validator registration should succeed"
+        );
+        assert!(
+            kreuzberg_register_validator(validator3.as_ptr(), failing_validator_callback, 25),
+            "Third validator registration should succeed"
+        );
+
+        let list_ptr = kreuzberg_list_validators();
+        let list_json = c_str_to_string(list_ptr).expect("Should have valid JSON");
+        kreuzberg_free_string(list_ptr);
+
+        assert!(list_json.contains("validator-1"), "Should contain validator-1");
+        assert!(list_json.contains("validator-2"), "Should contain validator-2");
+        assert!(list_json.contains("validator-3"), "Should contain validator-3");
+
+        kreuzberg_clear_validators();
+    }
+}
+
+/// Test unregistering validator.
+#[test]
+fn test_unregister_validator_succeeds() {
+    unsafe {
+        kreuzberg_clear_validators();
+
+        let name = CString::new("temp-validator").unwrap();
+        kreuzberg_register_validator(name.as_ptr(), passing_validator_callback, 50);
+
+        let result = kreuzberg_unregister_validator(name.as_ptr());
+        assert!(result, "Unregistration should succeed");
+
+        let list_ptr = kreuzberg_list_validators();
+        let list_json = c_str_to_string(list_ptr).expect("Should have valid JSON");
+        kreuzberg_free_string(list_ptr);
+
+        assert!(
+            !list_json.contains("temp-validator"),
+            "List should not contain unregistered validator"
+        );
+
+        kreuzberg_clear_validators();
+    }
+}
+
+/// Test unregistering non-existent validator fails gracefully.
+#[test]
+fn test_unregister_nonexistent_validator_fails_gracefully() {
+    unsafe {
+        kreuzberg_clear_validators();
+
+        let name = CString::new("nonexistent-validator").unwrap();
+        let result = kreuzberg_unregister_validator(name.as_ptr());
+
+        assert!(result, "Unregistering non-existent validator should succeed (no-op)");
+
+        kreuzberg_clear_validators();
+    }
+}
+
+/// Test registering validator with null name fails gracefully.
+#[test]
+fn test_register_validator_with_null_name_fails_gracefully() {
+    unsafe {
+        let result = kreuzberg_register_validator(ptr::null(), passing_validator_callback, 50);
+
+        assert!(!result, "Registration with null name should fail");
+
+        let error = get_last_error();
+        assert!(error.is_some(), "Should have error message");
+        let error_msg = error.unwrap();
+        assert!(
+            error_msg.contains("null") || error_msg.contains("invalid") || error_msg.contains("empty"),
+            "Error should mention null/invalid: {}",
+            error_msg
+        );
+    }
+}
+
+/// Test registering validator with empty name fails gracefully.
+#[test]
+fn test_register_validator_with_empty_name_fails_gracefully() {
+    unsafe {
+        let name = CString::new("").unwrap();
+        let result = kreuzberg_register_validator(name.as_ptr(), passing_validator_callback, 50);
+
+        assert!(!result, "Registration with empty name should fail");
+
+        let error = get_last_error();
+        assert!(error.is_some(), "Should have error message");
+        let error_msg = error.unwrap();
+        assert!(
+            error_msg.contains("empty") || error_msg.contains("invalid"),
+            "Error should mention empty/invalid: {}",
+            error_msg
+        );
+    }
+}
+
+/// Test registering validator with whitespace in name fails gracefully.
+#[test]
+fn test_register_validator_with_whitespace_in_name_fails_gracefully() {
+    unsafe {
+        let name = CString::new("validator with spaces").unwrap();
+        let result = kreuzberg_register_validator(name.as_ptr(), passing_validator_callback, 50);
+
+        assert!(!result, "Registration with whitespace in name should fail");
+
+        let error = get_last_error();
+        assert!(error.is_some(), "Should have error message");
+        let error_msg = error.unwrap();
+        assert!(
+            error_msg.contains("whitespace") || error_msg.contains("invalid"),
+            "Error should mention whitespace/invalid: {}",
+            error_msg
+        );
+    }
+}
+
+/// Test registering validator with invalid UTF-8 fails gracefully.
+#[test]
+fn test_register_validator_with_invalid_utf8_fails_gracefully() {
+    unsafe {
+        let invalid_bytes = vec![
+            b'v', b'a', b'l', b'i', b'd', b'a', b't', b'o', b'r', b'-', 0xFF, 0xFE, 0x00,
+        ];
+        let name_ptr = invalid_bytes.as_ptr() as *const i8;
+        let result = kreuzberg_register_validator(name_ptr, passing_validator_callback, 50);
+
+        assert!(!result, "Should fail with invalid UTF-8");
+        let error = get_last_error();
+        assert!(error.is_some(), "Should have error message on failure");
+        assert!(
+            error.unwrap().contains("Invalid UTF-8"),
+            "Error should mention UTF-8 issue"
+        );
+
+        kreuzberg_clear_validators();
+    }
+}
+
+/// Test clearing all validators.
+#[test]
+fn test_clear_validators_succeeds() {
+    unsafe {
+        kreuzberg_clear_validators();
+
+        let v1 = CString::new("validator-1").unwrap();
+        let v2 = CString::new("validator-2").unwrap();
+        kreuzberg_register_validator(v1.as_ptr(), passing_validator_callback, 50);
+        kreuzberg_register_validator(v2.as_ptr(), passing_validator_callback, 50);
+
+        let result = kreuzberg_clear_validators();
+        assert!(result, "Clear should succeed");
+
+        let list_ptr = kreuzberg_list_validators();
+        let list_json = c_str_to_string(list_ptr).expect("Should have valid JSON");
+        kreuzberg_free_string(list_ptr);
+
+        let validators: Vec<String> = serde_json::from_str(&list_json).unwrap_or_default();
+        assert_eq!(validators.len(), 0, "List should be empty after clear");
+    }
+}
+
+/// Test listing validators returns valid JSON.
+#[test]
+fn test_list_validators_returns_valid_json() {
+    unsafe {
+        kreuzberg_clear_validators();
+
+        let name = CString::new("test-validator").unwrap();
+        kreuzberg_register_validator(name.as_ptr(), passing_validator_callback, 50);
+
+        let list_ptr = kreuzberg_list_validators();
+        assert!(!list_ptr.is_null(), "List should not be null");
+
+        let list_json = c_str_to_string(list_ptr).expect("Should have valid JSON");
+        kreuzberg_free_string(list_ptr);
+
+        let validators: Vec<String> = serde_json::from_str(&list_json).expect("Should be valid JSON array");
+        assert!(
+            validators.contains(&"test-validator".to_string()),
+            "Should contain registered validator"
+        );
+
+        kreuzberg_clear_validators();
+    }
+}
+
+/// Test listing empty validators returns empty array.
+#[test]
+fn test_list_empty_validators_returns_empty_array() {
+    unsafe {
+        kreuzberg_clear_validators();
+
+        let list_ptr = kreuzberg_list_validators();
+        assert!(!list_ptr.is_null(), "List should not be null");
+
+        let list_json = c_str_to_string(list_ptr).expect("Should have valid JSON");
+        kreuzberg_free_string(list_ptr);
+
+        let validators: Vec<String> = serde_json::from_str(&list_json).expect("Should be valid JSON array");
+        assert_eq!(validators.len(), 0, "Should be empty array");
+    }
+}
+
+/// Test registering duplicate validator replaces previous one.
+#[test]
+fn test_register_duplicate_validator_replaces_previous() {
+    unsafe {
+        kreuzberg_clear_validators();
+
+        let name = CString::new("duplicate-validator").unwrap();
+
+        kreuzberg_register_validator(name.as_ptr(), passing_validator_callback, 50);
+
+        let result = kreuzberg_register_validator(name.as_ptr(), failing_validator_callback, 100);
+
+        assert!(result, "Duplicate registration should succeed (replace)");
+
+        let list_ptr = kreuzberg_list_validators();
+        let list_json = c_str_to_string(list_ptr).expect("Should have valid JSON");
+        kreuzberg_free_string(list_ptr);
+
+        let validators: Vec<String> = serde_json::from_str(&list_json).unwrap();
+        let duplicate_count = validators.iter().filter(|v| *v == "duplicate-validator").count();
+        assert_eq!(duplicate_count, 1, "Should only have one instance of the validator");
+
+        kreuzberg_clear_validators();
+    }
+}
+
+/// Test validator priorities are respected.
+#[test]
+fn test_validator_priorities_are_registered() {
+    unsafe {
+        kreuzberg_clear_validators();
+
+        let low_priority = CString::new("low-priority-validator").unwrap();
+        let high_priority = CString::new("high-priority-validator").unwrap();
+
+        kreuzberg_register_validator(low_priority.as_ptr(), passing_validator_callback, 10);
+        kreuzberg_register_validator(high_priority.as_ptr(), passing_validator_callback, 100);
+
+        let list_ptr = kreuzberg_list_validators();
+        let list_json = c_str_to_string(list_ptr).expect("Should have valid JSON");
+        kreuzberg_free_string(list_ptr);
+
+        assert!(
+            list_json.contains("low-priority-validator"),
+            "Should contain low priority validator"
+        );
+        assert!(
+            list_json.contains("high-priority-validator"),
+            "Should contain high priority validator"
+        );
+
+        kreuzberg_clear_validators();
+    }
+}
+
+/// Test listing OCR backends returns valid JSON.
+#[test]
+fn test_list_ocr_backends_returns_valid_json() {
+    unsafe {
+        let list_ptr = kreuzberg_list_ocr_backends();
+        assert!(!list_ptr.is_null(), "List should not be null");
+
+        let list_json = c_str_to_string(list_ptr).expect("Should have valid JSON");
+        kreuzberg_free_string(list_ptr);
+
+        let backends: Vec<String> = serde_json::from_str(&list_json).expect("Should be valid JSON array");
+
+        assert!(backends.is_empty() || !backends.is_empty(), "Should be a valid array");
+    }
+}
+
+/// Test unregistering non-existent OCR backend succeeds gracefully.
+#[test]
+fn test_unregister_nonexistent_ocr_backend_succeeds_gracefully() {
+    unsafe {
+        let name = CString::new("nonexistent-ocr-backend").unwrap();
+        let result = kreuzberg_unregister_ocr_backend(name.as_ptr());
+
+        assert!(result, "Unregistering non-existent OCR backend should succeed (no-op)");
+    }
+}
+
+/// Test unregistering OCR backend with null name fails gracefully.
+#[test]
+fn test_unregister_ocr_backend_with_null_name_fails_gracefully() {
+    unsafe {
+        let result = kreuzberg_unregister_ocr_backend(ptr::null());
+
+        assert!(!result, "Unregistration with null name should fail");
+
+        let error = get_last_error();
+        assert!(error.is_some(), "Should have error message");
+        let error_msg = error.unwrap();
+        assert!(
+            error_msg.contains("NULL") || error_msg.contains("null"),
+            "Error should mention null: {}",
+            error_msg
+        );
+    }
+}
+
+/// Test unregistering OCR backend with empty name fails gracefully.
+#[test]
+fn test_unregister_ocr_backend_with_empty_name_fails_gracefully() {
+    unsafe {
+        let name = CString::new("").unwrap();
+        let result = kreuzberg_unregister_ocr_backend(name.as_ptr());
+
+        assert!(!result, "Unregistration with empty name should fail");
+
+        let error = get_last_error();
+        assert!(error.is_some(), "Should have error message");
+        let error_msg = error.unwrap();
+        assert!(
+            error_msg.contains("empty") || error_msg.contains("invalid"),
+            "Error should mention empty/invalid: {}",
+            error_msg
+        );
+    }
+}
+
+/// Test unregistering OCR backend with whitespace in name fails gracefully.
+#[test]
+fn test_unregister_ocr_backend_with_whitespace_in_name_fails_gracefully() {
+    unsafe {
+        let name = CString::new("ocr backend with spaces").unwrap();
+        let result = kreuzberg_unregister_ocr_backend(name.as_ptr());
+
+        assert!(!result, "Unregistration with whitespace in name should fail");
+
+        let error = get_last_error();
+        assert!(error.is_some(), "Should have error message");
+        let error_msg = error.unwrap();
+        assert!(
+            error_msg.contains("whitespace") || error_msg.contains("invalid"),
+            "Error should mention whitespace/invalid: {}",
+            error_msg
+        );
+    }
+}
+
+/// Test unregistering OCR backend with invalid UTF-8 fails gracefully.
+#[test]
+fn test_unregister_ocr_backend_with_invalid_utf8_fails_gracefully() {
+    unsafe {
+        let invalid_bytes = [b'o', b'c', b'r', b'-', 0xFF, 0xFE, 0x00];
+        let name_ptr = invalid_bytes.as_ptr() as *const i8;
+        let result = kreuzberg_unregister_ocr_backend(name_ptr);
+
+        assert!(!result, "Should fail with invalid UTF-8");
+        let error = get_last_error();
+        assert!(error.is_some(), "Should have error message on failure");
+        assert!(
+            error.unwrap().contains("Invalid UTF-8"),
+            "Error should mention UTF-8 issue"
+        );
+    }
+}