leyline-http 0.1.5

HTTP client that impersonates Chrome, Firefox, and Safari on the wire: TLS (JA3/JA4), HTTP/2, and HTTP/3 fingerprints
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

use leyline::h2::config::PseudoOrder;
use leyline::h2::connection::PseudoHeaders;
use leyline::h2::error::{ErrorCode, H2Error};

const CHROME_ORDER: [PseudoOrder; 4] = [
    PseudoOrder::Method,
    PseudoOrder::Authority,
    PseudoOrder::Scheme,
    PseudoOrder::Path,
];

fn names<'a>(list: &[(&'a str, &'a str)]) -> Vec<&'a str> {
    list.iter().map(|(n, _)| *n).collect()
}

#[test]
fn classic_connect_omits_scheme_and_path() {
    let p = PseudoHeaders {
        method: "CONNECT".into(),
        scheme: "https".into(),
        authority: "example.com:443".into(),
        path: "/unused".into(),
        protocol: None,
    };
    let (list, len) = p.build_pseudo_list(&CHROME_ORDER).unwrap();
    let list = &list[..len];
    assert_eq!(names(list), vec![":method", ":authority"]);
    assert_eq!(list[0].1, "CONNECT");
    assert_eq!(list[1].1, "example.com:443");
}

#[test]
fn extended_connect_emits_protocol() {
    let p = PseudoHeaders {
        method: "CONNECT".into(),
        scheme: "https".into(),
        authority: "example.com:443".into(),
        path: "/chat".into(),
        protocol: Some("websocket".into()),
    };
    let (list, len) = p.build_pseudo_list(&CHROME_ORDER).unwrap();
    let list = &list[..len];
    assert_eq!(
        names(list),
        vec![":method", ":authority", ":scheme", ":path", ":protocol"]
    );
    assert_eq!(list[4].1, "websocket");
}

#[test]
fn non_connect_emits_all_four_pseudos() {
    let p = PseudoHeaders {
        method: "GET".into(),
        scheme: "https".into(),
        authority: "example.com".into(),
        path: "/".into(),
        protocol: None,
    };
    let (list, len) = p.build_pseudo_list(&CHROME_ORDER).unwrap();
    let list = &list[..len];
    assert_eq!(
        names(list),
        vec![":method", ":authority", ":scheme", ":path"]
    );
}

#[test]
fn non_connect_with_protocol_still_appends_it() {
    let p = PseudoHeaders {
        method: "GET".into(),
        scheme: "https".into(),
        authority: "example.com".into(),
        path: "/".into(),
        protocol: Some("websocket".into()),
    };
    let (list, len) = p.build_pseudo_list(&CHROME_ORDER).unwrap();
    let list = &list[..len];
    assert_eq!(list.last().map(|(n, _)| *n), Some(":protocol"));
}

#[test]
fn connect_without_authority_rejected() {
    let p = PseudoHeaders {
        method: "CONNECT".into(),
        scheme: "https".into(),
        authority: "".into(),
        path: "/".into(),
        protocol: None,
    };
    let err = p.build_pseudo_list(&CHROME_ORDER).unwrap_err();
    match err {
        H2Error::Connection { code, .. } => assert_eq!(code, ErrorCode::ProtocolError),
        other => panic!("expected Connection error, got {other:?}"),
    }
}

#[test]
fn pseudo_order_honoured_for_non_connect() {
    let order = [
        PseudoOrder::Method,
        PseudoOrder::Path,
        PseudoOrder::Authority,
        PseudoOrder::Scheme,
    ];
    let p = PseudoHeaders {
        method: "POST".into(),
        scheme: "https".into(),
        authority: "example.com".into(),
        path: "/api".into(),
        protocol: None,
    };
    let (list, len) = p.build_pseudo_list(&order).unwrap();
    let list = &list[..len];
    assert_eq!(
        names(list),
        vec![":method", ":path", ":authority", ":scheme"]
    );
}