aprender-serve 0.64.0

//! API Tests Part 16: Combinatorial API Sweep for openai_handlers.rs
//!
//! Protocol T-COV-95 Directive 1 (Popper Phase 2): Exercise all branches in
//! /v1/chat/completions through combinatorial testing:
//! - stream: true vs stream: false
//! - temperature: 0.0 (Greedy) vs temperature: 1.5 (Creative)
//! - max_tokens: 0 and max_tokens: very large
//! - Invalid JSON payloads (400 Bad Request)
//! - Empty messages arrays
//! - Non-existent models
//!
//! Goal: Lift openai_handlers.rs from 57% to 95%+ coverage.

use axum::{
    body::Body,
    http::{Request, StatusCode},
};
use tower::util::ServiceExt;

use crate::api::test_helpers::create_test_app_shared;

// =============================================================================
// Combinatorial Request Variations
// =============================================================================

/// Test stream=true vs stream=false with default model
#[tokio::test]
async fn test_chat_completions_stream_true() {
    let app = create_test_app_shared();

    let req_body = serde_json::json!({
        "model": "default",
        "messages": [{"role": "user", "content": "Hello"}],
        "stream": true
    });

    let request = Request::builder()
        .method("POST")
        .uri("/v1/chat/completions")
        .header("content-type", "application/json")
        .body(Body::from(serde_json::to_string(&req_body).expect("JSON serialization failed")))
        .expect("test value should be present");

    let response = app.oneshot(request).await.expect("test value should be present");
    // With no model loaded, should return error
    // aprender#2609: this was a disjunction over four or five statuses (several
    // listing NOT_FOUND twice), so it excluded nothing and passed against the
    // very behaviour #2609 reports. The shared test app is `demo_mock()` — a
    // server with no model of any kind — so the one correct answer for a
    // MOUNTED route is 503, and that is now what is asserted.
    crate::api::test_helpers::assert_no_model_status(response.status());
}

#[tokio::test]
async fn test_chat_completions_stream_false() {
    let app = create_test_app_shared();

    let req_body = serde_json::json!({
        "model": "default",
        "messages": [{"role": "user", "content": "Hello"}],
        "stream": false
    });

    let request = Request::builder()
        .method("POST")
        .uri("/v1/chat/completions")
        .header("content-type", "application/json")
        .body(Body::from(serde_json::to_string(&req_body).expect("JSON serialization failed")))
        .expect("test value should be present");

    let response = app.oneshot(request).await.expect("test value should be present");
    // aprender#2609: this was a disjunction over four or five statuses (several
    // listing NOT_FOUND twice), so it excluded nothing and passed against the
    // very behaviour #2609 reports. The shared test app is `demo_mock()` — a
    // server with no model of any kind — so the one correct answer for a
    // MOUNTED route is 503, and that is now what is asserted.
    crate::api::test_helpers::assert_no_model_status(response.status());
}

// =============================================================================
// Temperature Variations (Greedy vs Creative)
// =============================================================================

/// Test temperature=0.0 triggers greedy decoding (top_k=1 branch)
#[tokio::test]
async fn test_chat_completions_temperature_zero_greedy() {
    let app = create_test_app_shared();

    let req_body = serde_json::json!({
        "model": "default",
        "messages": [{"role": "user", "content": "Test greedy"}],
        "temperature": 0.0,
        "max_tokens": 10
    });

    let request = Request::builder()
        .method("POST")
        .uri("/v1/chat/completions")
        .header("content-type", "application/json")
        .body(Body::from(serde_json::to_string(&req_body).expect("JSON serialization failed")))
        .expect("test value should be present");

    let response = app.oneshot(request).await.expect("test value should be present");
    // Temperature 0.0 should trigger top_k=1 branch
    // aprender#2609: this was a disjunction over four or five statuses (several
    // listing NOT_FOUND twice), so it excluded nothing and passed against the
    // very behaviour #2609 reports. The shared test app is `demo_mock()` — a
    // server with no model of any kind — so the one correct answer for a
    // MOUNTED route is 503, and that is now what is asserted.
    crate::api::test_helpers::assert_no_model_status(response.status());
}

/// Test temperature=1.5 triggers creative decoding (top_k=40 branch)
#[tokio::test]
async fn test_chat_completions_temperature_creative() {
    let app = create_test_app_shared();

    let req_body = serde_json::json!({
        "model": "default",
        "messages": [{"role": "user", "content": "Test creative"}],
        "temperature": 1.5,
        "max_tokens": 10
    });

    let request = Request::builder()
        .method("POST")
        .uri("/v1/chat/completions")
        .header("content-type", "application/json")
        .body(Body::from(serde_json::to_string(&req_body).expect("JSON serialization failed")))
        .expect("test value should be present");

    let response = app.oneshot(request).await.expect("test value should be present");
    // aprender#2609: this was a disjunction over four or five statuses (several
    // listing NOT_FOUND twice), so it excluded nothing and passed against the
    // very behaviour #2609 reports. The shared test app is `demo_mock()` — a
    // server with no model of any kind — so the one correct answer for a
    // MOUNTED route is 503, and that is now what is asserted.
    crate::api::test_helpers::assert_no_model_status(response.status());
}

// =============================================================================
// max_tokens Edge Cases
// =============================================================================

/// Test max_tokens=0 (edge case, should be handled)
#[tokio::test]
async fn test_chat_completions_max_tokens_zero() {
    let app = create_test_app_shared();

    let req_body = serde_json::json!({
        "model": "default",
        "messages": [{"role": "user", "content": "Hello"}],
        "max_tokens": 0
    });

    let request = Request::builder()
        .method("POST")
        .uri("/v1/chat/completions")
        .header("content-type", "application/json")
        .body(Body::from(serde_json::to_string(&req_body).expect("JSON serialization failed")))
        .expect("test value should be present");

    let response = app.oneshot(request).await.expect("test value should be present");
    // max_tokens=0 might produce empty response or error
    // aprender#2609: this was a disjunction over four or five statuses (several
    // listing NOT_FOUND twice), so it excluded nothing and passed against the
    // very behaviour #2609 reports. The shared test app is `demo_mock()` — a
    // server with no model of any kind — so the one correct answer for a
    // MOUNTED route is 503, and that is now what is asserted.
    crate::api::test_helpers::assert_no_model_status(response.status());
}

/// Test max_tokens large (but not huge to avoid timeout)
#[tokio::test]
async fn test_chat_completions_max_tokens_large() {
    let app = create_test_app_shared();

    // Use 10000 instead of 1000000 to trigger large value handling without timeout
    let req_body = serde_json::json!({
        "model": "default",
        "messages": [{"role": "user", "content": "Hi"}],
        "max_tokens": 10000
    });

    let request = Request::builder()
        .method("POST")
        .uri("/v1/chat/completions")
        .header("content-type", "application/json")
        .body(Body::from(serde_json::to_string(&req_body).expect("JSON serialization failed")))
        .expect("test value should be present");

    let response = app.oneshot(request).await.expect("test value should be present");
    // aprender#2609: this was a disjunction over four or five statuses (several
    // listing NOT_FOUND twice), so it excluded nothing and passed against the
    // very behaviour #2609 reports. The shared test app is `demo_mock()` — a
    // server with no model of any kind — so the one correct answer for a
    // MOUNTED route is 503, and that is now what is asserted.
    crate::api::test_helpers::assert_no_model_status(response.status());
}

// =============================================================================
// Invalid JSON Payloads (400 Bad Request)
// =============================================================================

/// Test completely invalid JSON
#[tokio::test]
async fn test_chat_completions_invalid_json_syntax() {
    let app = create_test_app_shared();

    let request = Request::builder()
        .method("POST")
        .uri("/v1/chat/completions")
        .header("content-type", "application/json")
        .body(Body::from("{invalid json here"))
        .expect("test value should be present");

    let response = app.oneshot(request).await.expect("test value should be present");
    // 400 BAD_REQUEST for parse errors, 422 for structural errors
    assert_eq!(
        response.status(),
        StatusCode::BAD_REQUEST,
        "Invalid JSON syntax should return 400"
    );
}

/// Test JSON with wrong types
#[tokio::test]
async fn test_chat_completions_invalid_json_types() {
    let app = create_test_app_shared();

    // messages should be array, not string
    let req_body = serde_json::json!({
        "model": "default",
        "messages": "not an array"
    });

    let request = Request::builder()
        .method("POST")
        .uri("/v1/chat/completions")
        .header("content-type", "application/json")
        .body(Body::from(serde_json::to_string(&req_body).expect("JSON serialization failed")))
        .expect("test value should be present");

    let response = app.oneshot(request).await.expect("test value should be present");
    assert_eq!(
        response.status(),
        StatusCode::UNPROCESSABLE_ENTITY,
        "Wrong type should return 422"
    );
}

/// Test JSON missing required field 'messages'
#[tokio::test]
async fn test_chat_completions_missing_messages() {
    let app = create_test_app_shared();

    let req_body = serde_json::json!({
        "model": "default"
    });

    let request = Request::builder()
        .method("POST")
        .uri("/v1/chat/completions")
        .header("content-type", "application/json")
        .body(Body::from(serde_json::to_string(&req_body).expect("JSON serialization failed")))
        .expect("test value should be present");

    let response = app.oneshot(request).await.expect("test value should be present");
    assert_eq!(
        response.status(),
        StatusCode::UNPROCESSABLE_ENTITY,
        "Missing messages should return 422"
    );
}

/// Test JSON missing required field 'model'
#[tokio::test]
async fn test_chat_completions_missing_model() {
    let app = create_test_app_shared();

    let req_body = serde_json::json!({
        "messages": [{"role": "user", "content": "Hello"}]
    });

    let request = Request::builder()
        .method("POST")
        .uri("/v1/chat/completions")
        .header("content-type", "application/json")
        .body(Body::from(serde_json::to_string(&req_body).expect("JSON serialization failed")))
        .expect("test value should be present");

    let response = app.oneshot(request).await.expect("test value should be present");
    assert_eq!(
        response.status(),
        StatusCode::UNPROCESSABLE_ENTITY,
        "Missing model should return 422"
    );
}

// =============================================================================
// Empty Messages Array
// =============================================================================

/// Test empty messages array
#[tokio::test]
async fn test_chat_completions_empty_messages() {
    let app = create_test_app_shared();

    let req_body = serde_json::json!({
        "model": "default",
        "messages": []
    });

    let request = Request::builder()
        .method("POST")
        .uri("/v1/chat/completions")
        .header("content-type", "application/json")
        .body(Body::from(serde_json::to_string(&req_body).expect("JSON serialization failed")))
        .expect("test value should be present");

    let response = app.oneshot(request).await.expect("test value should be present");
    // Empty messages should trigger prompt_ids.is_empty() branch
    // aprender#2609: this was a disjunction over four or five statuses (several
    // listing NOT_FOUND twice), so it excluded nothing and passed against the
    // very behaviour #2609 reports. The shared test app is `demo_mock()` — a
    // server with no model of any kind — so the one correct answer for a
    // MOUNTED route is 503, and that is now what is asserted.
    crate::api::test_helpers::assert_no_model_status(response.status());
}

// =============================================================================
// Non-existent Models
// =============================================================================

/// Test request for model that doesn't exist
#[tokio::test]
async fn test_chat_completions_nonexistent_model() {
    let app = create_test_app_shared();

    let req_body = serde_json::json!({
        "model": "nonexistent-model-xyz-12345",
        "messages": [{"role": "user", "content": "Hello"}]
    });

    let request = Request::builder()
        .method("POST")
        .uri("/v1/chat/completions")
        .header("content-type", "application/json")
        .body(Body::from(serde_json::to_string(&req_body).expect("JSON serialization failed")))
        .expect("test value should be present");

    let response = app.oneshot(request).await.expect("test value should be present");
    // Non-existent model should fall through model branches
    // aprender#2609: this was a disjunction over four or five statuses (several
    // listing NOT_FOUND twice), so it excluded nothing and passed against the
    // very behaviour #2609 reports. The shared test app is `demo_mock()` — a
    // server with no model of any kind — so the one correct answer for a
    // MOUNTED route is 503, and that is now what is asserted.
    crate::api::test_helpers::assert_no_model_status(response.status());
}

/// Test request with empty model string
#[tokio::test]
async fn test_chat_completions_empty_model_string() {
    let app = create_test_app_shared();

    let req_body = serde_json::json!({
        "model": "",
        "messages": [{"role": "user", "content": "Hello"}]
    });

    let request = Request::builder()
        .method("POST")
        .uri("/v1/chat/completions")
        .header("content-type", "application/json")
        .body(Body::from(serde_json::to_string(&req_body).expect("JSON serialization failed")))
        .expect("test value should be present");

    let response = app.oneshot(request).await.expect("test value should be present");
    // Empty model string triggers request.model.is_empty() branch
    // aprender#2609: this was a disjunction over four or five statuses (several
    // listing NOT_FOUND twice), so it excluded nothing and passed against the
    // very behaviour #2609 reports. The shared test app is `demo_mock()` — a
    // server with no model of any kind — so the one correct answer for a
    // MOUNTED route is 503, and that is now what is asserted.
    crate::api::test_helpers::assert_no_model_status(response.status());
}

// =============================================================================
// Multi-Message Conversations
// =============================================================================

/// Test multi-turn conversation (system + user + assistant + user)
#[tokio::test]
async fn test_chat_completions_multi_turn() {
    let app = create_test_app_shared();

    let req_body = serde_json::json!({
        "model": "default",
        "messages": [
            {"role": "system", "content": "You are helpful."},
            {"role": "user", "content": "Hello"},
            {"role": "assistant", "content": "Hi there!"},
            {"role": "user", "content": "How are you?"}
        ]
    });

    let request = Request::builder()
        .method("POST")
        .uri("/v1/chat/completions")
        .header("content-type", "application/json")
        .body(Body::from(serde_json::to_string(&req_body).expect("JSON serialization failed")))
        .expect("test value should be present");

    let response = app.oneshot(request).await.expect("test value should be present");
    // aprender#2609: this was a disjunction over four or five statuses (several
    // listing NOT_FOUND twice), so it excluded nothing and passed against the
    // very behaviour #2609 reports. The shared test app is `demo_mock()` — a
    // server with no model of any kind — so the one correct answer for a
    // MOUNTED route is 503, and that is now what is asserted.
    crate::api::test_helpers::assert_no_model_status(response.status());
}

include!("chat_completions_03.rs");
include!("chat_completions_02_02.rs");
include!("registry_multiple.rs");