sark-h2 0.28.3

Fiber-free HTTP/2 protocol primitives and manifold server for sark
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

pub mod common;

use std::{iter, pin::Pin};

use common::{
    headers::{self, Generated},
    recipe::Reply,
};
use dope::core::driver::settings::Receive;
use o3::{base::cell::region, buffer::resident};
use sark_core::{
    body,
    decode::{Decode, request::Head as _},
    manifold::stream::Boundary,
};
use sark_h2::{
    ClientRole,
    conn::{event::Event, machine::Connection},
    server::{
        self,
        service::{FromFn, Handler, Route},
        sync::{Conn, Endpoint},
    },
};
use sark_http::payload::response::statics::Direct;

#[test]
fn dispatches_named() {
    let plan = server::Plan::new(
        server::Config {
            max_request_body_bytes: 0,
            max_request_body_chunks: 0,
            max_connection_body_bytes: 0,
            max_connection_body_chunks: 0,
            max_outbound_bytes: 4096,
        },
        Receive::fixed::<2, 4096>(),
    )
    .expect("response plan");
    let capacity = plan.resident_len();
    let mut domain = resident::Domain::new();
    region::Token::scope_pinned(Pin::new(&mut domain), |token, domain| {
        let budget = domain
            .get_mut()
            .try_budget(capacity, token.proof())
            .expect("ingress capacity");
        let handler = FromFn::new(Direct::reply).with_bound::<4096>();
        assert_eq!(size_of_val(&handler), 0);
        let endpoint = Endpoint::try_new(Route::new(handler), plan).expect("endpoint");
        let mut server = Conn::try_new(&endpoint).expect("server connection");
        server.ingress().try_bind(budget).expect("ingress budget");
        let mut client = Connection::<ClientRole>::try_new().expect("client connection");
        client
            .streams()
            .headers()
            .request(Generated(b""), Boundary::End)
            .expect("request");
        server
            .ingress()
            .ingest(client.output().first())
            .expect("request ingress");
        server.drain_events();
        client
            .ingress()
            .ingest(server.output().first())
            .expect("response ingress");
        let (data, boundary) = iter::from_fn(|| client.ingress().poll_event())
            .find_map(|event| match event {
                Event::Data { data, boundary, .. } => Some((data, boundary)),
                _ => None,
            })
            .expect("response data");
        assert_eq!(data.contiguous(), Some(b"named".as_slice()));
        assert_eq!(boundary, Boundary::End);
    });
}

#[test]
fn admitted_content_length() {
    let route = Route::new(FromFn::new(Direct::reply).with_bound::<4096>());
    for (limit, expected) in [
        (5, None),
        (
            4,
            Some(body::Error::TooLarge {
                actual: 5,
                limit: 4,
            }),
        ),
    ] {
        let head = headers::try_head(&[b"5, 5", b"05"])
            .expect("retained raw head")
            .into_parts()
            .0
            .try_request()
            .ok()
            .expect("valid request control");
        let selected = route.try_head(head).expect("admitted request length");
        assert_eq!(
            selected
                .try_start(limit, Boundary::More)
                .err()
                .map(|failure| failure.into_parts().1),
            expected,
        );
    }
}