kreuzberg 4.0.8 → 4.1.0

data/vendor/kreuzberg/src/core/server_config/tests/basic_tests.rs

@@ -0,0 +1,124 @@
+//! Basic tests for ServerConfig functionality.
+
+use crate::core::ServerConfig;
+
+#[test]
+fn test_default_config() {
+    let config = ServerConfig::default();
+    assert_eq!(config.host, "127.0.0.1");
+    assert_eq!(config.port, 8000);
+    assert!(config.cors_origins.is_empty());
+    assert_eq!(config.max_request_body_bytes, 104_857_600);
+    assert_eq!(config.max_multipart_field_bytes, 104_857_600);
+    assert!(config.max_upload_mb.is_none());
+}
+
+#[test]
+fn test_listen_addr() {
+    let config = ServerConfig::default();
+    assert_eq!(config.listen_addr(), "127.0.0.1:8000");
+}
+
+#[test]
+fn test_listen_addr_custom() {
+    let config = ServerConfig {
+        host: "0.0.0.0".to_string(),
+        port: 3000,
+        ..Default::default()
+    };
+    assert_eq!(config.listen_addr(), "0.0.0.0:3000");
+}
+
+#[test]
+fn test_cors_allows_all() {
+    let mut config = ServerConfig::default();
+    assert!(config.cors_allows_all());
+
+    config.cors_origins.push("https://example.com".to_string());
+    assert!(!config.cors_allows_all());
+}
+
+#[test]
+fn test_is_origin_allowed_all() {
+    let config = ServerConfig::default();
+    assert!(config.is_origin_allowed("https://example.com"));
+    assert!(config.is_origin_allowed("https://other.com"));
+}
+
+#[test]
+fn test_is_origin_allowed_specific() {
+    let mut config = ServerConfig::default();
+    config.cors_origins.push("https://allowed.com".to_string());
+
+    assert!(config.is_origin_allowed("https://allowed.com"));
+    assert!(!config.is_origin_allowed("https://denied.com"));
+}
+
+#[test]
+fn test_max_request_body_mb() {
+    let config = ServerConfig::default();
+    assert_eq!(config.max_request_body_mb(), 100);
+}
+
+#[test]
+fn test_max_multipart_field_mb() {
+    let config = ServerConfig::default();
+    assert_eq!(config.max_multipart_field_mb(), 100);
+}
+
+#[test]
+fn test_max_bytes_to_mb_rounding() {
+    let mut config = ServerConfig {
+        max_request_body_bytes: 1_048_576, // 1 MB
+        ..Default::default()
+    };
+    assert_eq!(config.max_request_body_mb(), 1);
+
+    config.max_request_body_bytes = 1_048_577; // 1 MB + 1 byte
+    assert_eq!(config.max_request_body_mb(), 2); // Rounds up
+}
+
+#[test]
+fn test_normalize_legacy_max_upload_mb() {
+    let mut config = ServerConfig {
+        max_upload_mb: Some(50),
+        ..Default::default()
+    };
+
+    config.normalize_legacy_fields();
+
+    assert_eq!(config.max_multipart_field_bytes, 50 * 1_048_576);
+}
+
+#[test]
+fn test_normalize_legacy_max_upload_mb_zero() {
+    let mut config = ServerConfig {
+        max_upload_mb: Some(0),
+        ..Default::default()
+    };
+
+    config.normalize_legacy_fields();
+
+    assert_eq!(config.max_multipart_field_bytes, 0);
+}
+
+#[test]
+fn test_serde_default_serialization() {
+    let config = ServerConfig::default();
+    let json = serde_json::to_string(&config).unwrap();
+
+    // Should serialize without the max_upload_mb field when None
+    assert!(!json.contains("max_upload_mb"));
+}
+
+#[test]
+fn test_serde_with_max_upload_mb_serialization() {
+    let config = ServerConfig {
+        max_upload_mb: Some(50),
+        ..Default::default()
+    };
+    let json = serde_json::to_string(&config).unwrap();
+
+    // Should serialize with max_upload_mb when Some
+    assert!(json.contains("max_upload_mb"));
+}

data/vendor/kreuzberg/src/core/server_config/tests/env_tests.rs

@@ -0,0 +1,216 @@
+//! Tests for environment variable overrides.
+
+#![allow(unsafe_code)]
+
+use crate::core::ServerConfig;
+
+#[serial_test::serial]
+#[test]
+fn test_apply_env_host_override() {
+    let original = std::env::var("KREUZBERG_HOST").ok();
+    unsafe {
+        std::env::set_var("KREUZBERG_HOST", "192.168.1.1");
+    }
+
+    let mut config = ServerConfig::default();
+    config.apply_env_overrides().unwrap();
+
+    assert_eq!(config.host, "192.168.1.1");
+
+    // Cleanup
+    unsafe {
+        if let Some(orig) = original {
+            std::env::set_var("KREUZBERG_HOST", orig);
+        } else {
+            std::env::remove_var("KREUZBERG_HOST");
+        }
+    }
+}
+
+#[serial_test::serial]
+#[test]
+fn test_apply_env_port_override() {
+    let original = std::env::var("KREUZBERG_PORT").ok();
+    unsafe {
+        std::env::set_var("KREUZBERG_PORT", "5000");
+    }
+
+    let mut config = ServerConfig::default();
+    config.apply_env_overrides().unwrap();
+
+    assert_eq!(config.port, 5000);
+
+    // Cleanup
+    unsafe {
+        if let Some(orig) = original {
+            std::env::set_var("KREUZBERG_PORT", orig);
+        } else {
+            std::env::remove_var("KREUZBERG_PORT");
+        }
+    }
+}
+
+#[serial_test::serial]
+#[test]
+fn test_apply_env_port_invalid() {
+    let original = std::env::var("KREUZBERG_PORT").ok();
+    unsafe {
+        std::env::set_var("KREUZBERG_PORT", "not_a_number");
+    }
+
+    let mut config = ServerConfig::default();
+    let result = config.apply_env_overrides();
+
+    assert!(result.is_err());
+    assert!(
+        result
+            .unwrap_err()
+            .to_string()
+            .contains("KREUZBERG_PORT must be a valid u16")
+    );
+
+    // Cleanup
+    unsafe {
+        if let Some(orig) = original {
+            std::env::set_var("KREUZBERG_PORT", orig);
+        } else {
+            std::env::remove_var("KREUZBERG_PORT");
+        }
+    }
+}
+
+#[serial_test::serial]
+#[test]
+fn test_apply_env_cors_origins_override() {
+    let original = std::env::var("KREUZBERG_CORS_ORIGINS").ok();
+    unsafe {
+        std::env::set_var("KREUZBERG_CORS_ORIGINS", "https://example.com, https://other.com");
+    }
+
+    let mut config = ServerConfig::default();
+    config.apply_env_overrides().unwrap();
+
+    assert_eq!(config.cors_origins.len(), 2);
+    assert!(config.cors_origins.contains(&"https://example.com".to_string()));
+    assert!(config.cors_origins.contains(&"https://other.com".to_string()));
+
+    // Cleanup
+    unsafe {
+        if let Some(orig) = original {
+            std::env::set_var("KREUZBERG_CORS_ORIGINS", orig);
+        } else {
+            std::env::remove_var("KREUZBERG_CORS_ORIGINS");
+        }
+    }
+}
+
+#[serial_test::serial]
+#[test]
+fn test_apply_env_max_request_body_bytes_override() {
+    let original = std::env::var("KREUZBERG_MAX_REQUEST_BODY_BYTES").ok();
+    unsafe {
+        std::env::set_var("KREUZBERG_MAX_REQUEST_BODY_BYTES", "52428800");
+    }
+
+    let mut config = ServerConfig::default();
+    config.apply_env_overrides().unwrap();
+
+    assert_eq!(config.max_request_body_bytes, 52_428_800);
+
+    // Cleanup
+    unsafe {
+        if let Some(orig) = original {
+            std::env::set_var("KREUZBERG_MAX_REQUEST_BODY_BYTES", orig);
+        } else {
+            std::env::remove_var("KREUZBERG_MAX_REQUEST_BODY_BYTES");
+        }
+    }
+}
+
+#[serial_test::serial]
+#[test]
+fn test_apply_env_max_multipart_field_bytes_override() {
+    let original = std::env::var("KREUZBERG_MAX_MULTIPART_FIELD_BYTES").ok();
+    unsafe {
+        std::env::set_var("KREUZBERG_MAX_MULTIPART_FIELD_BYTES", "78643200");
+    }
+
+    let mut config = ServerConfig::default();
+    config.apply_env_overrides().unwrap();
+
+    assert_eq!(config.max_multipart_field_bytes, 78_643_200);
+
+    // Cleanup
+    unsafe {
+        if let Some(orig) = original {
+            std::env::set_var("KREUZBERG_MAX_MULTIPART_FIELD_BYTES", orig);
+        } else {
+            std::env::remove_var("KREUZBERG_MAX_MULTIPART_FIELD_BYTES");
+        }
+    }
+}
+
+#[serial_test::serial]
+#[test]
+fn test_apply_env_legacy_max_upload_size_mb_override() {
+    let original = std::env::var("KREUZBERG_MAX_UPLOAD_SIZE_MB").ok();
+    unsafe {
+        std::env::set_var("KREUZBERG_MAX_UPLOAD_SIZE_MB", "75");
+    }
+
+    let mut config = ServerConfig::default();
+    config.apply_env_overrides().unwrap();
+
+    assert_eq!(config.max_upload_mb, Some(75));
+    assert_eq!(config.max_multipart_field_bytes, 75 * 1_048_576);
+
+    // Cleanup
+    unsafe {
+        if let Some(orig) = original {
+            std::env::set_var("KREUZBERG_MAX_UPLOAD_SIZE_MB", orig);
+        } else {
+            std::env::remove_var("KREUZBERG_MAX_UPLOAD_SIZE_MB");
+        }
+    }
+}
+
+#[serial_test::serial]
+#[test]
+fn test_apply_env_multiple_overrides() {
+    let host_orig = std::env::var("KREUZBERG_HOST").ok();
+    let port_orig = std::env::var("KREUZBERG_PORT").ok();
+    let cors_orig = std::env::var("KREUZBERG_CORS_ORIGINS").ok();
+
+    unsafe {
+        std::env::set_var("KREUZBERG_HOST", "0.0.0.0");
+        std::env::set_var("KREUZBERG_PORT", "4000");
+        std::env::set_var("KREUZBERG_CORS_ORIGINS", "https://api.example.com");
+    }
+
+    let mut config = ServerConfig::default();
+    config.apply_env_overrides().unwrap();
+
+    assert_eq!(config.host, "0.0.0.0");
+    assert_eq!(config.port, 4000);
+    assert_eq!(config.cors_origins.len(), 1);
+    assert_eq!(config.cors_origins[0], "https://api.example.com");
+
+    // Cleanup
+    unsafe {
+        if let Some(orig) = host_orig {
+            std::env::set_var("KREUZBERG_HOST", orig);
+        } else {
+            std::env::remove_var("KREUZBERG_HOST");
+        }
+        if let Some(orig) = port_orig {
+            std::env::set_var("KREUZBERG_PORT", orig);
+        } else {
+            std::env::remove_var("KREUZBERG_PORT");
+        }
+        if let Some(orig) = cors_orig {
+            std::env::set_var("KREUZBERG_CORS_ORIGINS", orig);
+        } else {
+            std::env::remove_var("KREUZBERG_CORS_ORIGINS");
+        }
+    }
+}

data/vendor/kreuzberg/src/core/server_config/tests/file_loading_tests.rs

@@ -0,0 +1,341 @@
+//! Tests for file loading functionality.
+
+use crate::core::ServerConfig;
+use std::fs;
+use tempfile::tempdir;
+
+#[test]
+fn test_from_toml_file() {
+    let dir = tempdir().unwrap();
+    let config_path = dir.path().join("server.toml");
+
+    fs::write(
+        &config_path,
+        r#"
+host = "0.0.0.0"
+port = 3000
+cors_origins = ["https://example.com", "https://other.com"]
+max_request_body_bytes = 50000000
+max_multipart_field_bytes = 75000000
+        "#,
+    )
+    .unwrap();
+
+    let config = ServerConfig::from_toml_file(&config_path).unwrap();
+    assert_eq!(config.host, "0.0.0.0");
+    assert_eq!(config.port, 3000);
+    assert_eq!(config.cors_origins.len(), 2);
+    assert_eq!(config.max_request_body_bytes, 50_000_000);
+    assert_eq!(config.max_multipart_field_bytes, 75_000_000);
+}
+
+#[test]
+fn test_from_yaml_file() {
+    let dir = tempdir().unwrap();
+    let config_path = dir.path().join("server.yaml");
+
+    fs::write(
+        &config_path,
+        r#"
+host: 0.0.0.0
+port: 3000
+cors_origins:
+  - https://example.com
+  - https://other.com
+max_request_body_bytes: 50000000
+max_multipart_field_bytes: 75000000
+        "#,
+    )
+    .unwrap();
+
+    let config = ServerConfig::from_yaml_file(&config_path).unwrap();
+    assert_eq!(config.host, "0.0.0.0");
+    assert_eq!(config.port, 3000);
+    assert_eq!(config.cors_origins.len(), 2);
+    assert_eq!(config.max_request_body_bytes, 50_000_000);
+    assert_eq!(config.max_multipart_field_bytes, 75_000_000);
+}
+
+#[test]
+fn test_from_json_file() {
+    let dir = tempdir().unwrap();
+    let config_path = dir.path().join("server.json");
+
+    fs::write(
+        &config_path,
+        r#"{
+  "host": "0.0.0.0",
+  "port": 3000,
+  "cors_origins": ["https://example.com", "https://other.com"],
+  "max_request_body_bytes": 50000000,
+  "max_multipart_field_bytes": 75000000
+}
+        "#,
+    )
+    .unwrap();
+
+    let config = ServerConfig::from_json_file(&config_path).unwrap();
+    assert_eq!(config.host, "0.0.0.0");
+    assert_eq!(config.port, 3000);
+    assert_eq!(config.cors_origins.len(), 2);
+    assert_eq!(config.max_request_body_bytes, 50_000_000);
+    assert_eq!(config.max_multipart_field_bytes, 75_000_000);
+}
+
+#[test]
+fn test_from_file_auto_detects_toml() {
+    let dir = tempdir().unwrap();
+    let config_path = dir.path().join("server.toml");
+
+    fs::write(
+        &config_path,
+        r#"
+host = "0.0.0.0"
+port = 3000
+        "#,
+    )
+    .unwrap();
+
+    let config = ServerConfig::from_file(&config_path).unwrap();
+    assert_eq!(config.host, "0.0.0.0");
+    assert_eq!(config.port, 3000);
+}
+
+#[test]
+fn test_from_file_auto_detects_yaml() {
+    let dir = tempdir().unwrap();
+    let config_path = dir.path().join("server.yaml");
+
+    fs::write(
+        &config_path,
+        r#"
+host: 0.0.0.0
+port: 3000
+        "#,
+    )
+    .unwrap();
+
+    let config = ServerConfig::from_file(&config_path).unwrap();
+    assert_eq!(config.host, "0.0.0.0");
+    assert_eq!(config.port, 3000);
+}
+
+#[test]
+fn test_from_file_auto_detects_json() {
+    let dir = tempdir().unwrap();
+    let config_path = dir.path().join("server.json");
+
+    fs::write(&config_path, r#"{"host": "0.0.0.0", "port": 3000}"#).unwrap();
+
+    let config = ServerConfig::from_file(&config_path).unwrap();
+    assert_eq!(config.host, "0.0.0.0");
+    assert_eq!(config.port, 3000);
+}
+
+#[test]
+fn test_from_file_unsupported_extension() {
+    let dir = tempdir().unwrap();
+    let config_path = dir.path().join("server.txt");
+
+    fs::write(&config_path, "host = 0.0.0.0").unwrap();
+
+    let result = ServerConfig::from_file(&config_path);
+    assert!(result.is_err());
+    assert!(
+        result
+            .unwrap_err()
+            .to_string()
+            .contains("Unsupported config file format")
+    );
+}
+
+#[test]
+fn test_from_file_no_extension() {
+    let dir = tempdir().unwrap();
+    let config_path = dir.path().join("server");
+
+    fs::write(&config_path, "host = 0.0.0.0").unwrap();
+
+    let result = ServerConfig::from_file(&config_path);
+    assert!(result.is_err());
+    assert!(result.unwrap_err().to_string().contains("no extension found"));
+}
+
+#[test]
+fn test_legacy_max_upload_mb_in_file() {
+    let dir = tempdir().unwrap();
+    let config_path = dir.path().join("server.toml");
+
+    fs::write(
+        &config_path,
+        r#"
+host = "127.0.0.1"
+port = 8000
+max_upload_mb = 50
+        "#,
+    )
+    .unwrap();
+
+    let config = ServerConfig::from_toml_file(&config_path).unwrap();
+    assert_eq!(config.max_upload_mb, Some(50));
+    assert_eq!(config.max_multipart_field_bytes, 50 * 1_048_576);
+}
+
+#[test]
+fn test_cors_origins_empty_in_toml() {
+    let dir = tempdir().unwrap();
+    let config_path = dir.path().join("server.toml");
+
+    fs::write(
+        &config_path,
+        r#"
+host = "127.0.0.1"
+port = 8000
+        "#,
+    )
+    .unwrap();
+
+    let config = ServerConfig::from_toml_file(&config_path).unwrap();
+    assert!(config.cors_origins.is_empty());
+    assert!(config.cors_allows_all());
+}
+
+#[test]
+fn test_full_configuration_toml() {
+    let dir = tempdir().unwrap();
+    let config_path = dir.path().join("server.toml");
+
+    fs::write(
+        &config_path,
+        r#"
+host = "192.168.1.100"
+port = 9000
+cors_origins = ["https://app1.com", "https://app2.com", "https://app3.com"]
+max_request_body_bytes = 200000000
+max_multipart_field_bytes = 150000000
+        "#,
+    )
+    .unwrap();
+
+    let config = ServerConfig::from_toml_file(&config_path).unwrap();
+    assert_eq!(config.host, "192.168.1.100");
+    assert_eq!(config.port, 9000);
+    assert_eq!(config.listen_addr(), "192.168.1.100:9000");
+    assert_eq!(config.cors_origins.len(), 3);
+    assert!(!config.cors_allows_all());
+    assert!(config.is_origin_allowed("https://app1.com"));
+    assert!(!config.is_origin_allowed("https://app4.com"));
+    assert_eq!(config.max_request_body_bytes, 200_000_000);
+    assert_eq!(config.max_multipart_field_bytes, 150_000_000);
+    assert_eq!(config.max_request_body_mb(), 191);
+    assert_eq!(config.max_multipart_field_mb(), 144);
+}
+
+#[test]
+fn test_from_file_with_nested_server_section_toml() {
+    let dir = tempdir().unwrap();
+    let config_path = dir.path().join("kreuzberg.toml");
+
+    // Config file with [server] section and other sections (like ExtractionConfig)
+    fs::write(
+        &config_path,
+        r#"
+[server]
+host = "0.0.0.0"
+port = 3000
+cors_origins = ["https://example.com"]
+
+[ocr]
+backend = "tesseract"
+language = "eng"
+
+[extraction]
+enabled = true
+        "#,
+    )
+    .unwrap();
+
+    let config = ServerConfig::from_file(&config_path).unwrap();
+    assert_eq!(config.host, "0.0.0.0");
+    assert_eq!(config.port, 3000);
+    assert_eq!(config.cors_origins.len(), 1);
+    assert_eq!(config.cors_origins[0], "https://example.com");
+}
+
+#[test]
+fn test_from_file_with_nested_server_section_yaml() {
+    let dir = tempdir().unwrap();
+    let config_path = dir.path().join("kreuzberg.yaml");
+
+    // Config file with server: section and other sections
+    fs::write(
+        &config_path,
+        r#"
+server:
+  host: 0.0.0.0
+  port: 4000
+  cors_origins:
+    - https://example.com
+
+ocr:
+  backend: tesseract
+  language: eng
+        "#,
+    )
+    .unwrap();
+
+    let config = ServerConfig::from_file(&config_path).unwrap();
+    assert_eq!(config.host, "0.0.0.0");
+    assert_eq!(config.port, 4000);
+    assert_eq!(config.cors_origins.len(), 1);
+}
+
+#[test]
+fn test_from_file_with_nested_server_section_json() {
+    let dir = tempdir().unwrap();
+    let config_path = dir.path().join("kreuzberg.json");
+
+    // Config file with "server" key and other sections
+    fs::write(
+        &config_path,
+        r#"
+{
+  "server": {
+    "host": "0.0.0.0",
+    "port": 5000,
+    "cors_origins": ["https://example.com"]
+  },
+  "ocr": {
+    "backend": "tesseract",
+    "language": "eng"
+  }
+}
+        "#,
+    )
+    .unwrap();
+
+    let config = ServerConfig::from_file(&config_path).unwrap();
+    assert_eq!(config.host, "0.0.0.0");
+    assert_eq!(config.port, 5000);
+    assert_eq!(config.cors_origins.len(), 1);
+}
+
+#[test]
+fn test_from_file_flat_format_still_works() {
+    let dir = tempdir().unwrap();
+    let config_path = dir.path().join("server.toml");
+
+    // Old flat format without [server] section
+    fs::write(
+        &config_path,
+        r#"
+host = "192.168.1.1"
+port = 6000
+        "#,
+    )
+    .unwrap();
+
+    let config = ServerConfig::from_file(&config_path).unwrap();
+    assert_eq!(config.host, "192.168.1.1");
+    assert_eq!(config.port, 6000);
+}

data/vendor/kreuzberg/src/core/server_config/tests/mod.rs

@@ -0,0 +1,5 @@
+//! Tests for server configuration module.
+
+mod basic_tests;
+mod env_tests;
+mod file_loading_tests;

data/vendor/kreuzberg/src/core/server_config/validation.rs

@@ -0,0 +1,17 @@
+//! Validation and normalization for server configuration.
+//!
+//! This module provides functionality to validate and normalize server configuration
+//! values, including legacy field migration.
+
+/// Normalize legacy field values for backward compatibility.
+///
+/// If `max_upload_mb` is set, it will be converted to bytes and used to
+/// override `max_multipart_field_bytes`. This allows old configurations
+/// using the legacy field to continue working.
+pub fn normalize_legacy_fields(max_upload_mb: Option<usize>, max_multipart_field_bytes: &mut usize) {
+    if let Some(max_upload_mb_value) = max_upload_mb {
+        // Convert MB to bytes
+        let max_bytes = max_upload_mb_value.saturating_mul(1_048_576);
+        *max_multipart_field_bytes = max_bytes;
+    }
+}