sipp-rs 0.1.0

Unified Rust library for extensible Sipp inference
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90

//! Unit tests for the parent module.

use super::*;

#[test]
fn provider_error_kind_from_code_maps_retry_relevant_codes() {
    assert_eq!(
        provider_error_kind_from_code(Some("rate_limit")),
        Some(ProviderErrorKind::RateLimited)
    );
    assert_eq!(
        provider_error_kind_from_code(Some("insufficient_quota")),
        Some(ProviderErrorKind::QuotaExceeded)
    );
    assert_eq!(
        provider_error_kind_from_code(Some("overloaded_error")),
        Some(ProviderErrorKind::Overloaded)
    );
    assert_eq!(provider_error_kind_from_code(Some("bad_request")), None);
}

#[test]
fn provider_error_kind_from_code_maps_gateway_stable_codes() {
    for (code, kind) in [
        ("authentication", ProviderErrorKind::Authentication),
        ("authorization", ProviderErrorKind::Authorization),
        ("invalid_request", ProviderErrorKind::InvalidRequest),
        ("unsupported_feature", ProviderErrorKind::UnsupportedFeature),
        ("model_not_found", ProviderErrorKind::ModelNotFound),
        ("overloaded", ProviderErrorKind::Overloaded),
        ("quota_exceeded", ProviderErrorKind::QuotaExceeded),
        ("rate_limited", ProviderErrorKind::RateLimited),
        ("timeout", ProviderErrorKind::Timeout),
        ("transport", ProviderErrorKind::Transport),
    ] {
        assert_eq!(
            provider_error_kind_from_code(Some(code)),
            Some(kind),
            "{code}"
        );
    }
}

#[test]
fn provider_error_debug_redacts_provider_payloads() {
    let error = ProviderError {
        kind: ProviderErrorKind::Authentication,
        provider: ProviderKind::OpenAiCompatible,
        status: Some(401),
        code: Some("provider-secret-code".to_string()),
        message: "provider rejected provider-secret-token".to_string(),
        retry_after: Some(std::time::Duration::from_millis(500)),
        request_id: Some("req-provider-secret-token".to_string()),
        raw: Some(Box::new(serde_json::json!({
            "error": {
                "message": "provider-secret-token",
                "code": "provider-secret-code"
            }
        }))),
    };

    let debug = format!("{error:?}");

    assert!(!debug.contains("provider-secret"));
    assert!(debug.contains("[redacted]"));
}

#[test]
fn provider_error_display_does_not_expose_provider_payloads() {
    let error = ProviderError {
        kind: ProviderErrorKind::Authentication,
        provider: ProviderKind::OpenAiCompatible,
        status: Some(401),
        code: Some("provider-secret-code".to_string()),
        message: "provider rejected provider-secret-token".to_string(),
        retry_after: Some(std::time::Duration::from_millis(500)),
        request_id: Some("req-provider-secret-token".to_string()),
        raw: Some(Box::new(serde_json::json!({
            "error": {
                "message": "provider-secret-token",
                "code": "provider-secret-code"
            }
        }))),
    };

    let display = error.to_string();

    assert!(!display.contains("provider-secret"));
    assert!(display.contains("OpenAiCompatible provider error (Authentication)"));
}