http-type 18.1.0

A comprehensive Rust library providing essential types for HTTP operations. Includes core HTTP abstractions (request/response, methods, status codes, versions), content types, cookies, WebSocket support, and thread-safe concurrent types (ArcMutex, ArcRwLock). Also provides convenient Option-wrapped primitive types for flexible HTTP handling.
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

use crate::*;

#[test]
fn test_http_url_components_parse_http() {
    let result: Result<HttpUrlComponents, HttpUrlError> =
        HttpUrlComponents::parse("http://example.com/path?query=1#frag");
    assert!(result.is_ok());
    let components: HttpUrlComponents = result.unwrap();
    assert_eq!(components.protocol, "http");
    assert_eq!(components.host, Some("example.com".to_string()));
    assert_eq!(components.port, None);
    assert_eq!(components.path, Some("/path".to_string()));
    assert_eq!(components.query, Some("query=1".to_string()));
    assert_eq!(components.fragment, Some("frag".to_string()));
}

#[test]
fn test_http_url_components_parse_https_with_port() {
    let result: Result<HttpUrlComponents, HttpUrlError> =
        HttpUrlComponents::parse("https://example.com:8443/");
    assert!(result.is_ok());
    let components: HttpUrlComponents = result.unwrap();
    assert_eq!(components.protocol, "https");
    assert_eq!(components.host, Some("example.com".to_string()));
    assert_eq!(components.port, Some(8443));
    assert_eq!(components.path, Some("/".to_string()));
}

#[test]
fn test_http_url_components_default() {
    let components: HttpUrlComponents = HttpUrlComponents::default();
    assert_eq!(components.protocol, "");
    assert_eq!(components.host, None);
    assert_eq!(components.port, None);
    assert_eq!(components.path, None);
    assert_eq!(components.query, None);
    assert_eq!(components.fragment, None);
}

#[test]
fn test_http_url_components_clone() {
    let components: HttpUrlComponents = HttpUrlComponents {
        protocol: "https".to_string(),
        host: Some("example.com".to_string()),
        ..Default::default()
    };
    let cloned: HttpUrlComponents = components.clone();
    assert_eq!(cloned.protocol, "https");
    assert_eq!(cloned.host, Some("example.com".to_string()));
}

#[test]
fn test_http_url_components_eq() {
    let a: HttpUrlComponents = HttpUrlComponents {
        protocol: "http".to_string(),
        ..Default::default()
    };
    let b: HttpUrlComponents = HttpUrlComponents {
        protocol: "http".to_string(),
        ..Default::default()
    };
    assert_eq!(a, b);
}

#[test]
fn test_http_url_error_display_invalid_url() {
    let error: HttpUrlError = HttpUrlError::InvalidUrl;
    assert_eq!(format!("{error}"), "Invalid URL");
}

#[test]
fn test_http_url_error_display_unknown() {
    let error: HttpUrlError = HttpUrlError::Unknown;
    assert_eq!(format!("{error}"), "Unknown error");
}

#[test]
fn test_http_url_error_default() {
    let error: HttpUrlError = HttpUrlError::default();
    assert_eq!(error, HttpUrlError::Unknown);
}

#[test]
fn test_http_url_error_from_parse_error() {
    let parse_error: ParseError = "not a url".parse::<Url>().unwrap_err();
    let error: HttpUrlError = HttpUrlError::from(parse_error);
    assert_eq!(error, HttpUrlError::InvalidUrl);
}