qubit-http 0.5.0

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

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

//! Coverage-only tests for defensive branches.

use qubit_http::{coverage_support, HttpErrorKind};

#[test]
fn test_coverage_support_exercises_backend_error_mapper_paths() {
    assert_eq!(
        coverage_support::classify_backend_error_kinds(),
        vec![
            HttpErrorKind::Decode,
            HttpErrorKind::Status,
            HttpErrorKind::InvalidUrl,
            HttpErrorKind::Transport,
        ]
    );

    assert_eq!(
        coverage_support::classify_timeout_kinds(),
        vec![
            HttpErrorKind::ConnectTimeout,
            HttpErrorKind::RequestTimeout,
            HttpErrorKind::ReadTimeout,
            HttpErrorKind::RequestTimeout,
        ]
    );
}

#[test]
fn test_coverage_support_exercises_http_retry_mapping_paths() {
    let diagnostics = coverage_support::exercise_http_retry_mapping_paths();

    assert!(diagnostics
        .iter()
        .any(|message| message.contains("attempts exhausted")),);
    assert!(diagnostics
        .iter()
        .any(|message| message.contains("retry aborted")),);
    assert!(diagnostics
        .iter()
        .any(|message| message.contains("retry executor failed")),);
    assert!(diagnostics
        .iter()
        .any(|message| message.contains("max duration exceeded")),);
    assert_eq!(
        coverage_support::exercise_retry_failure_decision_path(),
        "UseDefault"
    );
}

#[tokio::test]
async fn test_coverage_support_exercises_response_and_request_paths() {
    let (kind, message) = coverage_support::validate_non_utf8_sse_content_type();
    assert_eq!(kind, HttpErrorKind::SseProtocol);
    assert!(message.contains("non-UTF8 Content-Type"));

    let response_diagnostics = coverage_support::exercise_response_preview_paths().await;
    assert!(response_diagnostics
        .iter()
        .any(|message| message.contains("abc")),);
    assert!(response_diagnostics
        .iter()
        .any(|message| message.contains("<empty>")),);
    assert!(response_diagnostics
        .iter()
        .any(|message| message.contains("Cancelled")),);

    let request_diagnostics = coverage_support::exercise_request_cache_paths().await;
    assert!(request_diagnostics
        .iter()
        .any(|message| message.contains("coverage-cache")),);
    assert!(request_diagnostics.iter().any(|message| message == "0"),);
}

#[tokio::test]
async fn test_coverage_support_exercises_threshold_paths() {
    let diagnostics = coverage_support::exercise_threshold_paths().await;

    assert!(diagnostics
        .iter()
        .any(|message| message.contains("No IPv4 address found")),);
    assert!(diagnostics.iter().any(|message| message == "1"),);
    assert!(diagnostics.iter().any(|message| message == "coverage"),);
    assert!(diagnostics.iter().any(|message| message == "ProxyConfig"),);
    assert!(diagnostics.iter().any(|message| message == "Other"),);
    assert!(diagnostics
        .iter()
        .any(|message| message == "/relative-only"),);
    assert!(diagnostics.iter().any(|message| message == "Cancelled"),);
}