kreuzberg 4.0.0.pre.rc.29 → 4.0.0.rc1

data/vendor/kreuzberg/tests/api_embed.rs

@@ -1,360 +0,0 @@
-//! Integration tests for the /embed API endpoint.
-
-#![cfg(all(feature = "api", feature = "embeddings"))]
-
-use axum::{
-    body::Body,
-    http::{Request, StatusCode},
-};
-use serde_json::json;
-use tower::ServiceExt;
-
-use kreuzberg::{
-    ExtractionConfig,
-    api::{EmbedResponse, create_router},
-};
-
-/// Test embed endpoint with valid texts.
-#[tokio::test]
-async fn test_embed_valid_texts() {
-    let app = create_router(ExtractionConfig::default());
-
-    let request_body = json!({
-        "texts": ["Hello world", "Second text"]
-    });
-
-    let response = app
-        .oneshot(
-            Request::builder()
-                .method("POST")
-                .uri("/embed")
-                .header("content-type", "application/json")
-                .body(Body::from(serde_json::to_string(&request_body).unwrap()))
-                .unwrap(),
-        )
-        .await
-        .unwrap();
-
-    assert_eq!(response.status(), StatusCode::OK);
-
-    let body = axum::body::to_bytes(response.into_body(), usize::MAX).await.unwrap();
-    let embed_response: EmbedResponse = serde_json::from_slice(&body).unwrap();
-
-    assert_eq!(embed_response.count, 2);
-    assert_eq!(embed_response.embeddings.len(), 2);
-    assert!(embed_response.dimensions > 0);
-    assert!(!embed_response.model.is_empty());
-
-    // Verify embeddings have correct dimensions
-    for embedding in &embed_response.embeddings {
-        assert_eq!(embedding.len(), embed_response.dimensions);
-    }
-}
-
-/// Test embed endpoint with empty texts array returns 400.
-#[tokio::test]
-async fn test_embed_empty_texts() {
-    let app = create_router(ExtractionConfig::default());
-
-    let request_body = json!({
-        "texts": []
-    });
-
-    let response = app
-        .oneshot(
-            Request::builder()
-                .method("POST")
-                .uri("/embed")
-                .header("content-type", "application/json")
-                .body(Body::from(serde_json::to_string(&request_body).unwrap()))
-                .unwrap(),
-        )
-        .await
-        .unwrap();
-
-    assert_eq!(response.status(), StatusCode::BAD_REQUEST);
-}
-
-/// Test embed endpoint with custom embedding configuration.
-#[tokio::test]
-async fn test_embed_with_custom_config() {
-    let app = create_router(ExtractionConfig::default());
-
-    let request_body = json!({
-        "texts": ["Test embedding with custom config"],
-        "config": {
-            "model": {
-                "preset": {
-                    "name": "fast"
-                }
-            },
-            "batch_size": 32
-        }
-    });
-
-    let response = app
-        .oneshot(
-            Request::builder()
-                .method("POST")
-                .uri("/embed")
-                .header("content-type", "application/json")
-                .body(Body::from(serde_json::to_string(&request_body).unwrap()))
-                .unwrap(),
-        )
-        .await
-        .unwrap();
-
-    assert_eq!(response.status(), StatusCode::OK);
-
-    let body = axum::body::to_bytes(response.into_body(), usize::MAX).await.unwrap();
-    let embed_response: EmbedResponse = serde_json::from_slice(&body).unwrap();
-
-    assert_eq!(embed_response.count, 1);
-    assert_eq!(embed_response.embeddings.len(), 1);
-    assert_eq!(embed_response.model, "fast");
-}
-
-/// Test embed endpoint with single text.
-#[tokio::test]
-async fn test_embed_single_text() {
-    let app = create_router(ExtractionConfig::default());
-
-    let request_body = json!({
-        "texts": ["Single text for embedding"]
-    });
-
-    let response = app
-        .oneshot(
-            Request::builder()
-                .method("POST")
-                .uri("/embed")
-                .header("content-type", "application/json")
-                .body(Body::from(serde_json::to_string(&request_body).unwrap()))
-                .unwrap(),
-        )
-        .await
-        .unwrap();
-
-    assert_eq!(response.status(), StatusCode::OK);
-
-    let body = axum::body::to_bytes(response.into_body(), usize::MAX).await.unwrap();
-    let embed_response: EmbedResponse = serde_json::from_slice(&body).unwrap();
-
-    assert_eq!(embed_response.count, 1);
-    assert_eq!(embed_response.embeddings.len(), 1);
-}
-
-/// Test embed endpoint with multiple texts (batch).
-#[tokio::test]
-async fn test_embed_batch() {
-    let app = create_router(ExtractionConfig::default());
-
-    let texts: Vec<String> = (0..10).map(|i| format!("Test text number {}", i)).collect();
-
-    let request_body = json!({
-        "texts": texts
-    });
-
-    let response = app
-        .oneshot(
-            Request::builder()
-                .method("POST")
-                .uri("/embed")
-                .header("content-type", "application/json")
-                .body(Body::from(serde_json::to_string(&request_body).unwrap()))
-                .unwrap(),
-        )
-        .await
-        .unwrap();
-
-    assert_eq!(response.status(), StatusCode::OK);
-
-    let body = axum::body::to_bytes(response.into_body(), usize::MAX).await.unwrap();
-    let embed_response: EmbedResponse = serde_json::from_slice(&body).unwrap();
-
-    assert_eq!(embed_response.count, 10);
-    assert_eq!(embed_response.embeddings.len(), 10);
-
-    // Verify all embeddings have the same dimensions
-    let first_dim = embed_response.embeddings[0].len();
-    for embedding in &embed_response.embeddings {
-        assert_eq!(embedding.len(), first_dim);
-    }
-}
-
-/// Test embed endpoint with long text.
-#[tokio::test]
-async fn test_embed_long_text() {
-    let app = create_router(ExtractionConfig::default());
-
-    let long_text = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. ".repeat(100);
-
-    let request_body = json!({
-        "texts": [long_text]
-    });
-
-    let response = app
-        .oneshot(
-            Request::builder()
-                .method("POST")
-                .uri("/embed")
-                .header("content-type", "application/json")
-                .body(Body::from(serde_json::to_string(&request_body).unwrap()))
-                .unwrap(),
-        )
-        .await
-        .unwrap();
-
-    assert_eq!(response.status(), StatusCode::OK);
-
-    let body = axum::body::to_bytes(response.into_body(), usize::MAX).await.unwrap();
-    let embed_response: EmbedResponse = serde_json::from_slice(&body).unwrap();
-
-    assert_eq!(embed_response.count, 1);
-    assert_eq!(embed_response.embeddings.len(), 1);
-}
-
-/// Test embed endpoint with malformed JSON returns 400.
-#[tokio::test]
-async fn test_embed_malformed_json() {
-    let app = create_router(ExtractionConfig::default());
-
-    let response = app
-        .oneshot(
-            Request::builder()
-                .method("POST")
-                .uri("/embed")
-                .header("content-type", "application/json")
-                .body(Body::from("{invalid json}"))
-                .unwrap(),
-        )
-        .await
-        .unwrap();
-
-    assert_eq!(response.status(), StatusCode::BAD_REQUEST);
-}
-
-/// Test embed endpoint preserves embedding vector values across calls.
-#[tokio::test]
-async fn test_embed_deterministic() {
-    let app = create_router(ExtractionConfig::default());
-
-    let request_body = json!({
-        "texts": ["Deterministic test"]
-    });
-
-    // First call
-    let response1 = app
-        .clone()
-        .oneshot(
-            Request::builder()
-                .method("POST")
-                .uri("/embed")
-                .header("content-type", "application/json")
-                .body(Body::from(serde_json::to_string(&request_body).unwrap()))
-                .unwrap(),
-        )
-        .await
-        .unwrap();
-
-    assert_eq!(response1.status(), StatusCode::OK);
-
-    let body1 = axum::body::to_bytes(response1.into_body(), usize::MAX).await.unwrap();
-    let embed_response1: EmbedResponse = serde_json::from_slice(&body1).unwrap();
-
-    // Second call with same text
-    let response2 = app
-        .oneshot(
-            Request::builder()
-                .method("POST")
-                .uri("/embed")
-                .header("content-type", "application/json")
-                .body(Body::from(serde_json::to_string(&request_body).unwrap()))
-                .unwrap(),
-        )
-        .await
-        .unwrap();
-
-    assert_eq!(response2.status(), StatusCode::OK);
-
-    let body2 = axum::body::to_bytes(response2.into_body(), usize::MAX).await.unwrap();
-    let embed_response2: EmbedResponse = serde_json::from_slice(&body2).unwrap();
-
-    // Compare embeddings - they should be identical
-    assert_eq!(embed_response1.embeddings.len(), embed_response2.embeddings.len());
-    assert_eq!(embed_response1.embeddings[0], embed_response2.embeddings[0]);
-}
-
-/// Test embed endpoint with different embedding presets.
-#[tokio::test]
-async fn test_embed_different_presets() {
-    let app = create_router(ExtractionConfig::default());
-
-    // Test with "fast" preset
-    let request_fast = json!({
-        "texts": ["Test text"],
-        "config": {
-            "model": {
-                "preset": {
-                    "name": "fast"
-                }
-            }
-        }
-    });
-
-    let response_fast = app
-        .clone()
-        .oneshot(
-            Request::builder()
-                .method("POST")
-                .uri("/embed")
-                .header("content-type", "application/json")
-                .body(Body::from(serde_json::to_string(&request_fast).unwrap()))
-                .unwrap(),
-        )
-        .await
-        .unwrap();
-
-    assert_eq!(response_fast.status(), StatusCode::OK);
-
-    let body_fast = axum::body::to_bytes(response_fast.into_body(), usize::MAX)
-        .await
-        .unwrap();
-    let embed_fast: EmbedResponse = serde_json::from_slice(&body_fast).unwrap();
-
-    // Test with "balanced" preset
-    let request_balanced = json!({
-        "texts": ["Test text"],
-        "config": {
-            "model": {
-                "preset": {
-                    "name": "balanced"
-                }
-            }
-        }
-    });
-
-    let response_balanced = app
-        .oneshot(
-            Request::builder()
-                .method("POST")
-                .uri("/embed")
-                .header("content-type", "application/json")
-                .body(Body::from(serde_json::to_string(&request_balanced).unwrap()))
-                .unwrap(),
-        )
-        .await
-        .unwrap();
-
-    assert_eq!(response_balanced.status(), StatusCode::OK);
-
-    let body_balanced = axum::body::to_bytes(response_balanced.into_body(), usize::MAX)
-        .await
-        .unwrap();
-    let embed_balanced: EmbedResponse = serde_json::from_slice(&body_balanced).unwrap();
-
-    // Different presets should have different dimensions
-    assert_ne!(embed_fast.dimensions, embed_balanced.dimensions);
-    assert_eq!(embed_fast.model, "fast");
-    assert_eq!(embed_balanced.model, "balanced");
-}

data/vendor/kreuzberg/tests/api_extract_multipart.rs

@@ -1,52 +0,0 @@
-#![cfg(feature = "api")]
-//! Integration test for the `/extract` API handler using multipart uploads.
-
-use axum::{
-    body::{Body, to_bytes},
-    http::{Request, StatusCode},
-};
-use kreuzberg::{
-    ExtractionConfig,
-    api::{ApiSizeLimits, create_router_with_limits},
-};
-use serde_json::Value;
-use tower::ServiceExt;
-
-#[tokio::test]
-async fn test_extract_accepts_single_file_multipart() {
-    let router = create_router_with_limits(ExtractionConfig::default(), ApiSizeLimits::from_mb(5, 5));
-
-    let boundary = "X-BOUNDARY";
-    let body = format!(
-        "--{boundary}\r\n\
-Content-Disposition: form-data; name=\"files\"; filename=\"test.txt\"\r\n\
-Content-Type: text/plain\r\n\
-\r\n\
-Hello world\r\n\
---{boundary}--\r\n"
-    );
-    let body_bytes = body.into_bytes();
-
-    let request = Request::builder()
-        .method("POST")
-        .uri("/extract")
-        .header("content-type", format!("multipart/form-data; boundary={boundary}"))
-        .header("content-length", body_bytes.len())
-        .body(Body::from(body_bytes))
-        .expect("Failed to build request");
-
-    let response = router.oneshot(request).await.expect("Request failed");
-    assert_eq!(response.status(), StatusCode::OK);
-
-    let bytes = to_bytes(response.into_body(), 1_000_000)
-        .await
-        .expect("Failed to read body");
-    let value: Value = serde_json::from_slice(&bytes).expect("Response JSON parse failed");
-    let content = value
-        .get(0)
-        .and_then(|v| v.get("content"))
-        .and_then(Value::as_str)
-        .expect("Response should include extracted content");
-
-    assert_eq!(content.trim_end_matches('\n'), "Hello world");
-}