qubit-http 0.4.2

General-purpose HTTP infrastructure for Rust with unified client semantics, secure logging, and built-in SSE decoding
Documentation 
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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

/*******************************************************************************
 *
 *    Copyright (c) 2025 - 2026.
 *    Haixing Hu, Qubit Co. Ltd.
 *
 *    All rights reserved.
 *
 ******************************************************************************/

use qubit_common::DataType;
use qubit_config::Config;
use qubit_http::{HttpConfigError, HttpConfigErrorKind};

#[test]
fn test_http_config_error_display() {
    let e = HttpConfigError::missing("http.proxy.host", "host is missing");
    let s = e.to_string();
    assert!(s.contains("missing field"));
    assert!(s.contains("http.proxy.host"));
    assert!(s.contains("host is missing"));
}

#[test]
fn test_http_config_error_constructors() {
    let e = HttpConfigError::type_error("path.field", "bad type");
    assert_eq!(e.kind, HttpConfigErrorKind::TypeError);
    assert_eq!(e.path, "path.field");

    let e = HttpConfigError::invalid_value("path.val", "out of range");
    assert_eq!(e.kind, HttpConfigErrorKind::InvalidValue);

    let e = HttpConfigError::invalid_header("path.hdr", "bad header");
    assert_eq!(e.kind, HttpConfigErrorKind::InvalidHeader);

    let e = HttpConfigError::config_error("path.cfg", "underlying error");
    assert_eq!(e.kind, HttpConfigErrorKind::ConfigError);
}

#[test]
fn test_http_config_error_is_std_error() {
    let e = HttpConfigError::missing("a.b", "msg");
    let _: &dyn std::error::Error = &e;
}

#[test]
fn test_http_config_error_from_config_error() {
    let mut config = Config::new();
    config
        .set("x", 42i32)
        .expect("test config should accept integer value");
    let ce = config
        .get_strict::<bool>("x")
        .expect_err("strictly reading integer as bool should fail");
    let he = HttpConfigError::from(ce);
    assert_eq!(he.kind, HttpConfigErrorKind::TypeError);
    assert_eq!(he.path, "x");
}

#[test]
fn test_http_config_error_from_property_has_no_value_maps_to_type_error() {
    let error = HttpConfigError::from(qubit_config::ConfigError::PropertyHasNoValue(
        "svc.token".to_string(),
    ));

    assert_eq!(error.kind, HttpConfigErrorKind::TypeError);
    assert_eq!(error.path, "svc.token");
}

#[test]
fn test_http_config_error_from_property_not_found_maps_to_config_error_with_path() {
    let error = HttpConfigError::from(qubit_config::ConfigError::PropertyNotFound(
        "svc.base_url".to_string(),
    ));

    assert_eq!(error.kind, HttpConfigErrorKind::ConfigError);
    assert_eq!(error.path, "svc.base_url");
}

#[test]
fn test_http_config_error_from_conversion_error_maps_to_type_error() {
    let error = HttpConfigError::from(qubit_config::ConfigError::ConversionError {
        key: "svc.timeout".to_string(),
        message: "bad duration".to_string(),
    });

    assert_eq!(error.kind, HttpConfigErrorKind::TypeError);
    assert_eq!(error.path, "svc.timeout");
}

#[test]
fn test_http_config_error_from_other_config_error_maps_to_config_error_without_path() {
    let error = HttpConfigError::from(qubit_config::ConfigError::Other("boom".to_string()));

    assert_eq!(error.kind, HttpConfigErrorKind::ConfigError);
    assert_eq!(error.path, "");
    assert!(error.message.contains("boom"));
}

#[test]
fn test_http_config_error_from_type_mismatch_maps_to_type_error() {
    let error = HttpConfigError::from(qubit_config::ConfigError::TypeMismatch {
        key: "svc.retries".to_string(),
        expected: DataType::Int32,
        actual: DataType::String,
    });

    assert_eq!(error.kind, HttpConfigErrorKind::TypeError);
    assert_eq!(error.path, "svc.retries");
}

#[test]
fn test_http_config_error_new() {
    let error = HttpConfigError::new(
        HttpConfigErrorKind::ConfigError,
        "service.timeout",
        "value out of range",
    );

    assert_eq!(error.kind, HttpConfigErrorKind::ConfigError);
    assert_eq!(error.path, "service.timeout");
    assert_eq!(error.message, "value out of range");
}