leyline-http 0.1.1

HTTP client that mimics browsers on the wire
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

use super::connect::connect_err;
use super::*;
use crate::h2::{ErrorCode, H2Error};
use crate::tls::TlsError;
use crate::{Error, Kind};

#[test]
fn transport_separates_the_keyspace() {
    let tcp = make_key("http", "example.com", 443, None, Transport::Tcp);
    let quic = make_key("https", "example.com", 443, None, Transport::Quic);
    assert_ne!(tcp, quic, "H2 (Tcp) and H3 (Quic) must not share a key");

    assert_eq!(
        tcp,
        make_key("http", "example.com", 443, None, Transport::Tcp)
    );

    assert_ne!(
        tcp,
        make_key("http", "example.com", 443, Some("p:8080"), Transport::Tcp)
    );
}

#[test]
fn kinds() {
    let tcp = Error::new(Kind::Tls).with_source(TlsError::TcpConnect(
        std::io::ErrorKind::ConnectionRefused.into(),
    ));
    let tcp = connect_err(&tcp);
    assert!(matches!(
        tcp.tls(),
        Some(TlsError::TcpConnect(err)) if err.kind() == std::io::ErrorKind::ConnectionRefused
    ));

    let handshake = Error::new(Kind::Tls).with_source(TlsError::HandshakeIo(
        std::io::ErrorKind::UnexpectedEof.into(),
    ));
    let handshake = connect_err(&handshake);
    assert!(matches!(
        handshake.tls(),
        Some(TlsError::HandshakeIo(err)) if err.kind() == std::io::ErrorKind::UnexpectedEof
    ));

    let io = Error::new(Kind::Io)
        .with_source(std::io::Error::from(std::io::ErrorKind::ConnectionAborted));
    let io = connect_err(&io);
    assert!(
        io.io()
            .is_some_and(|e| e.kind() == std::io::ErrorKind::ConnectionAborted)
    );
}

#[test]
fn a_joined_connect_error_keeps_its_http2_cause() {
    let goaway = Error::new(Kind::Http2).with_source(H2Error::Connection {
        code: ErrorCode::NoError,
        reason: "server shutting down".into(),
    });
    let joined = connect_err(&goaway);
    assert!(
        matches!(
            joined.h2(),
            Some(H2Error::Connection {
                code: ErrorCode::NoError,
                ..
            })
        ),
        "{joined:?}"
    );
    assert!(goaway.is_retryable() && joined.is_retryable(), "{joined:?}");
}