tez 0.0.3

A lightweight, ergonomic, and fast high-level HTTP client for Rust
Documentation
//! End-to-end protocol and transport behavior.

use std::{
    convert::Infallible,
    future::Future,
    io::{Read as _, Write as _},
    net::TcpListener,
    thread,
    time::Duration,
};

use bytes::Bytes;
use futures_util::{AsyncReadExt as _, AsyncWriteExt as _};
use http_body::Frame;
use http_body_util::{Full, StreamBody};
use hyper::service::service_fn;
use hyper_util::rt::TokioIo;
use tez::{
    Client, Method, StatusCode, Timeouts, Version,
    connection::{Http2, Settings},
    header, proxy,
};

fn upgrade_peer() -> (String, thread::JoinHandle<()>) {
    let listener = TcpListener::bind(("127.0.0.1", 0)).unwrap();
    let address = listener.local_addr().unwrap();
    let peer = thread::spawn(move || {
        let (mut stream, _) = listener.accept().unwrap();
        read_headers(&mut stream);
        stream
            .write_all(
                b"HTTP/1.1 101 Switching Protocols\r\nConnection: upgrade\r\nUpgrade: test\r\n\r\nhello",
            )
            .unwrap();
        let mut request = [0; 4];
        stream.read_exact(&mut request).unwrap();
        assert_eq!(&request, b"ping");
        stream.write_all(b"pong").unwrap();
    });
    (format!("http://{address}/upgrade"), peer)
}

#[tokio::test]
async fn an_http_upgrade_returns_the_connection_with_prefetched_bytes() {
    let (url, peer) = upgrade_peer();
    let response = Client::new()
        .unwrap()
        .get(url)
        .header(header::CONNECTION, "upgrade")
        .header(header::UPGRADE, "test")
        .send()
        .await
        .unwrap();

    assert_eq!(response.status(), StatusCode::SWITCHING_PROTOCOLS);
    assert_eq!(response.info().attempts(), 1);
    assert_eq!(response.info().redirects(), 0);
    let mut stream = response.upgrade().await.unwrap();
    let mut greeting = [0; 5];
    stream.read_exact(&mut greeting).await.unwrap();
    assert_eq!(&greeting, b"hello");
    stream.write_all(b"ping").await.unwrap();
    stream.flush().await.unwrap();
    let mut reply = [0; 4];
    stream.read_exact(&mut reply).await.unwrap();
    assert_eq!(&reply, b"pong");
    peer.join().unwrap();
}

#[test]
fn a_blocking_http_upgrade_returns_a_readable_and_writable_connection() {
    let (url, peer) = upgrade_peer();
    let response = tez::blocking::Client::new()
        .unwrap()
        .get(url)
        .header(header::CONNECTION, "upgrade")
        .header(header::UPGRADE, "test")
        .send()
        .unwrap();

    let mut stream = response.upgrade().unwrap();
    let mut greeting = [0; 5];
    stream.read_exact(&mut greeting).unwrap();
    assert_eq!(&greeting, b"hello");
    stream.write_all(b"ping").unwrap();
    stream.flush().unwrap();
    let mut reply = [0; 4];
    stream.read_exact(&mut reply).unwrap();
    assert_eq!(&reply, b"pong");
    peer.join().unwrap();
}

#[derive(Clone)]
struct Spawn;

impl<F> hyper::rt::Executor<F> for Spawn
where
    F: Future<Output = ()> + Send + 'static,
{
    fn execute(&self, future: F) {
        tokio::spawn(future);
    }
}

async fn http2_connect_peer() -> (String, tokio::task::JoinHandle<()>) {
    let listener = tokio::net::TcpListener::bind(("127.0.0.1", 0))
        .await
        .unwrap();
    let address = listener.local_addr().unwrap();
    let peer = tokio::spawn(async move {
        // Accept one socket: the follow-up request can only succeed if the
        // CONNECT stream leaves the multiplexed HTTP/2 connection reusable.
        let (stream, _) = listener.accept().await.unwrap();
        hyper::server::conn::http2::Builder::new(Spawn)
            .serve_connection(
                TokioIo::new(stream),
                service_fn(|mut request| async move {
                    assert_eq!(request.version(), Version::HTTP_2);
                    if request.method() == Method::CONNECT {
                        let upgrade = hyper::upgrade::on(&mut request);
                        tokio::spawn(async move {
                            use tokio::io::{AsyncReadExt as _, AsyncWriteExt as _};

                            let mut tunnel = TokioIo::new(upgrade.await.unwrap());
                            let mut message = [0; 4];
                            tunnel.read_exact(&mut message).await.unwrap();
                            assert_eq!(&message, b"ping");
                            tunnel.write_all(b"pong").await.unwrap();
                        });
                        Ok::<_, Infallible>(hyper::Response::new(Full::new(Bytes::new())))
                    } else {
                        assert_eq!(request.method(), Method::GET);
                        Ok(hyper::Response::new(Full::new(Bytes::from_static(
                            b"pooled",
                        ))))
                    }
                }),
            )
            .await
            .unwrap();
    });
    (format!("http://{address}"), peer)
}

#[tokio::test]
async fn an_http2_connect_returns_a_duplex_stream_and_keeps_the_connection_reusable() {
    let (base_url, peer) = http2_connect_peer().await;
    let client = Client::builder()
        .connection(Settings::default().http2(Http2::default().prior_knowledge(true)))
        .timeouts(Timeouts::default().total(Duration::from_secs(1)))
        .build()
        .unwrap();

    let response = client
        .connect(format!("{base_url}/tunnel"))
        .send()
        .await
        .unwrap();
    assert_eq!(response.status(), StatusCode::OK);
    assert_eq!(response.version(), Version::HTTP_2);

    let mut tunnel = response.upgrade().await.unwrap();
    tunnel.write_all(b"ping").await.unwrap();
    tunnel.flush().await.unwrap();
    let mut reply = [0; 4];
    tunnel.read_exact(&mut reply).await.unwrap();
    assert_eq!(&reply, b"pong");

    let response = client
        .get(format!("{base_url}/pooled"))
        .send()
        .await
        .unwrap();
    assert_eq!(response.version(), Version::HTTP_2);
    assert_eq!(response.bytes().await.unwrap(), "pooled");

    drop(tunnel);
    drop(client);
    peer.await.unwrap();
}

#[tokio::test(flavor = "multi_thread")]
async fn a_blocking_http2_connect_returns_a_readable_and_writable_stream() {
    let (base_url, peer) = http2_connect_peer().await;
    tokio::task::spawn_blocking(move || {
        let client = tez::blocking::Client::builder()
            .connection(Settings::default().http2(Http2::default().prior_knowledge(true)))
            .timeout(Duration::from_secs(1))
            .build()
            .unwrap();
        let response = client.connect(format!("{base_url}/tunnel")).send().unwrap();
        assert_eq!(response.status(), StatusCode::OK);
        assert_eq!(response.version(), Version::HTTP_2);

        let mut tunnel = response.upgrade().unwrap();
        tunnel.write_all(b"ping").unwrap();
        tunnel.flush().unwrap();
        let mut reply = [0; 4];
        tunnel.read_exact(&mut reply).unwrap();
        assert_eq!(&reply, b"pong");

        let response = client.get(format!("{base_url}/pooled")).send().unwrap();
        assert_eq!(response.version(), Version::HTTP_2);
        assert_eq!(response.bytes().unwrap(), "pooled");
    })
    .await
    .unwrap();
    peer.await.unwrap();
}

#[tokio::test]
async fn cleartext_http2_prior_knowledge_uses_http2_without_an_upgrade() {
    let listener = tokio::net::TcpListener::bind(("127.0.0.1", 0))
        .await
        .unwrap();
    let address = listener.local_addr().unwrap();
    let server = tokio::spawn(async move {
        let (stream, _) = listener.accept().await.unwrap();
        hyper::server::conn::http2::Builder::new(Spawn)
            .serve_connection(
                TokioIo::new(stream),
                service_fn(|request| async move {
                    assert_eq!(request.version(), Version::HTTP_2);
                    Ok::<_, Infallible>(hyper::Response::new(Full::new(Bytes::from_static(b"h2"))))
                }),
            )
            .await
            .unwrap();
    });
    let client = Client::builder()
        .connection(Settings::default().http2(Http2::default().prior_knowledge(true)))
        .build()
        .unwrap();

    let response = client
        .get(format!("http://{address}/h2"))
        .send()
        .await
        .unwrap();

    assert_eq!(response.version(), Version::HTTP_2);
    assert_eq!(response.bytes().await.unwrap(), "h2");
    drop(client);
    server.await.unwrap();
}

#[tokio::test]
async fn slow_http2_response_bodies_report_timeouts() {
    let listener = tokio::net::TcpListener::bind(("127.0.0.1", 0))
        .await
        .unwrap();
    let address = listener.local_addr().unwrap();
    let server = tokio::spawn(async move {
        let (stream, _) = listener.accept().await.unwrap();
        let _ = hyper::server::conn::http2::Builder::new(Spawn)
            .serve_connection(
                TokioIo::new(stream),
                service_fn(|_| async move {
                    let frames = futures_util::stream::once(async {
                        tokio::time::sleep(Duration::from_millis(100)).await;
                        Ok::<_, Infallible>(Frame::data(Bytes::from_static(b"late")))
                    });
                    Ok::<_, Infallible>(hyper::Response::new(StreamBody::new(frames)))
                }),
            )
            .await;
    });
    let client = Client::builder()
        .connection(Settings::default().http2(Http2::default().prior_knowledge(true)))
        .timeouts(
            Timeouts::default()
                .total(Duration::from_secs(1))
                .read(Duration::from_millis(20)),
        )
        .build()
        .unwrap();

    let response = client
        .get(format!("http://{address}/slow"))
        .send()
        .await
        .unwrap();
    assert_eq!(response.version(), Version::HTTP_2);
    assert!(response.bytes().await.unwrap_err().is_timeout());
    drop(client);
    server.await.unwrap();
}

#[tokio::test]
async fn a_socks5h_proxy_resolves_the_destination_and_authenticates() {
    let listener = TcpListener::bind(("127.0.0.1", 0)).unwrap();
    let address = listener.local_addr().unwrap();
    let proxy_peer = thread::spawn(move || {
        let (mut stream, _) = listener.accept().unwrap();
        let mut greeting = [0; 3];
        stream.read_exact(&mut greeting).unwrap();
        assert_eq!(greeting, [5, 1, 2]);
        stream.write_all(&[5, 2]).unwrap();

        let mut auth_header = [0; 2];
        stream.read_exact(&mut auth_header).unwrap();
        assert_eq!(auth_header, [1, 4]);
        let mut username = [0; 4];
        stream.read_exact(&mut username).unwrap();
        assert_eq!(&username, b"user");
        let mut password_length = [0; 1];
        stream.read_exact(&mut password_length).unwrap();
        let mut password = vec![0; usize::from(password_length[0])];
        stream.read_exact(&mut password).unwrap();
        assert_eq!(&password, b"secret");
        stream.write_all(&[1, 0]).unwrap();

        let mut connect = [0; 5];
        stream.read_exact(&mut connect).unwrap();
        assert_eq!(&connect[..4], &[5, 1, 0, 3]);
        let mut host = vec![0; usize::from(connect[4])];
        stream.read_exact(&mut host).unwrap();
        assert_eq!(&host, b"origin.invalid");
        let mut port = [0; 2];
        stream.read_exact(&mut port).unwrap();
        assert_eq!(u16::from_be_bytes(port), 80);
        stream
            .write_all(&[5, 0, 0, 1, 127, 0, 0, 1, 0, 80])
            .unwrap();

        read_headers(&mut stream);
        stream
            .write_all(b"HTTP/1.1 200 OK\r\nContent-Length: 5\r\nConnection: close\r\n\r\nsocks")
            .unwrap();
    });
    let client = Client::builder()
        .proxy(proxy::Policy::all(format!(
            "socks5h://user:secret@{address}"
        )))
        .build()
        .unwrap();

    let response = client
        .get("http://origin.invalid/proxied")
        .send()
        .await
        .unwrap();

    assert_eq!(response.bytes().await.unwrap(), "socks");
    proxy_peer.join().unwrap();
}

fn read_headers(stream: &mut std::net::TcpStream) {
    let mut request = Vec::new();
    let mut byte = [0; 1];
    while !request.ends_with(b"\r\n\r\n") {
        stream.read_exact(&mut byte).unwrap();
        request.push(byte[0]);
    }
}