sark-http 0.29.5

HTTP wire types, semantics, codecs, and ownership invariants 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

pub mod common;

use common::field::sections::{HOST, PATH, REQUEST};
use o3::buffer::pool;
use sark_http::{
    field::metadata::{
        block,
        map::record::Span,
        section::{rules, state::decode::Session, storage},
    },
    request,
};

#[test]
fn retains_owner_and_shape() {
    for length in [PATH.len(), 1] {
        let lease = pool::Span::try_new(256).expect("lease");
        let mut session = Session::<rules::RetainRaw>::try_new(
            lease,
            rules::Kind::Request,
            block::Connect::Disabled,
            storage::Scratch::default(),
        )
        .map_err(|(_, error)| error)
        .expect("session");
        for field in REQUEST.into_iter().chain([HOST]) {
            let name = block::Named::from_slice(field.name);
            session.indexed(Some(name)).expect("select");
            session
                .field::<rules::RejectPush>(
                    name,
                    block::Valued::from_span(Span::from_slice(field.value)),
                    field.indexing,
                )
                .expect("field");
        }
        let (head, _, _, _) = session.finish().1.expect("finish").into_parts();
        let head = head.try_request().ok().expect("request");
        let bytes = head.fields().as_bytes().as_ptr();
        let path = head
            .fields()
            .ranges()
            .find(|(field, _)| field.name == REQUEST[2].name)
            .map(|(_, range)| range)
            .expect("path");
        let pseudo = head
            .fields()
            .ranges()
            .find(|(field, _)| field.name == REQUEST[3].name)
            .map(|(_, range)| range)
            .expect("authority");
        let host = head
            .fields()
            .ranges()
            .find(|(field, _)| field.name == HOST.name)
            .map(|(_, range)| range)
            .expect("host");
        // SAFETY: all field ranges came from this exact native RetainRaw head.
        let bound = unsafe {
            request::raw::Bind::try_bind(head, Some(path), Some(length), Some(pseudo), Some(host))
        };
        if length != PATH.len() {
            assert_eq!(bound.err(), Some(request::Error::InvalidRange));
            continue;
        }
        let (owner, layout) = bound.expect("bound").into_parts();
        assert_eq!(owner.as_bytes().as_ptr(), bytes);
        assert_eq!(layout.route_path(owner.as_bytes()), Some(PATH));
        assert_eq!(
            layout.authority_in(owner.as_bytes()),
            Some(REQUEST[3].value)
        );
    }
}