qubit-http 0.5.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

/*******************************************************************************
 *
 *    Copyright (c) 2025 - 2026 Haixing Hu.
 *
 *    SPDX-License-Identifier: Apache-2.0
 *
 *    Licensed under the Apache License, Version 2.0.
 *
 ******************************************************************************/

use http::Method;
use qubit_http::{
    HttpClientFactory,
    HttpError,
    HttpErrorKind,
    HttpRequestInterceptor,
    HttpRequestInterceptors,
};
use url::Url;

#[test]
fn test_request_interceptors_apply_uses_parsed_path_when_resolved_url_cache_missing() {
    let client = HttpClientFactory::new()
        .create_default()
        .expect("default options should create client");
    let mut request = client.request(Method::GET, "http://[::1]/resource").build();
    request.set_ipv4_only(true);
    assert!(request.resolved_url_cached().is_none());

    let mut interceptors = HttpRequestInterceptors::new();
    interceptors.push(HttpRequestInterceptor::new(|_request| {
        Err(HttpError::other("request interceptor failed unexpectedly"))
    }));

    let error = interceptors
        .apply(&mut request)
        .expect_err("interceptor failure should be propagated");
    assert_eq!(error.kind, HttpErrorKind::Other);
    assert_eq!(error.method, Some(Method::GET));
    assert_eq!(
        error.url,
        Some(Url::parse("http://[::1]/resource").unwrap())
    );
}

#[test]
fn test_request_interceptors_apply_keeps_url_empty_when_path_is_not_absolute() {
    let client = HttpClientFactory::new()
        .create_default()
        .expect("default options should create client");
    let mut request = client.request(Method::GET, "/relative-only").build();
    assert!(request.resolved_url_cached().is_none());

    let mut interceptors = HttpRequestInterceptors::new();
    interceptors.push(HttpRequestInterceptor::new(|_request| {
        Err(HttpError::other("request interceptor failed"))
    }));

    let error = interceptors
        .apply(&mut request)
        .expect_err("interceptor failure should be propagated");
    assert_eq!(error.kind, HttpErrorKind::Other);
    assert_eq!(error.method, Some(Method::GET));
    assert!(error.url.is_none());
}

#[test]
fn test_request_interceptors_apply_preserves_existing_error_url() {
    let client = HttpClientFactory::new()
        .create_default()
        .expect("default options should create client");
    let mut request = client.request(Method::GET, "/relative-only").build();
    let expected_url =
        Url::parse("https://upstream.example/interceptor-failed").expect("URL should parse");

    let mut interceptors = HttpRequestInterceptors::new();
    interceptors.push(HttpRequestInterceptor::new({
        let expected_url = expected_url.clone();
        move |_request| Err(HttpError::other("request interceptor failed").with_url(&expected_url))
    }));

    let error = interceptors
        .apply(&mut request)
        .expect_err("interceptor failure should be propagated");
    assert_eq!(error.kind, HttpErrorKind::Other);
    assert_eq!(error.method, Some(Method::GET));
    assert_eq!(error.url, Some(expected_url));
}