coil-runtime 0.1.1

HTTP runtime and request handling for the Coil framework.
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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

use std::collections::BTreeMap;

use axum::body::to_bytes;
use axum::http::{HeaderMap, StatusCode};
use coil_wasm::{CacheVisibility, TypedCacheHint, TypedMetadata};

use super::{LiveCacheHeaders, LiveResponseAnnotations, LiveResponseComposition};

#[test]
fn cache_headers_use_structured_cache_hint_over_raw_string_values() {
    let cache_hint = TypedCacheHint::new(
        CacheVisibility::Private,
        120,
        Some(30),
        true,
        false,
        true,
        ["route-cache", "locale-cache"],
    )
    .unwrap();
    let headers = LiveCacheHeaders::from_parts(
        BTreeMap::from([
            (
                "Cache-Control".to_string(),
                "public, max-age=3600".to_string(),
            ),
            ("Surrogate-Key".to_string(), "stale legacy".to_string()),
            ("X-Trace".to_string(), "preserve".to_string()),
        ]),
        Some(&cache_hint),
    );

    let mut rendered = HeaderMap::new();
    for header in headers.rendered_headers() {
        rendered.insert(header.name, header.value);
    }

    assert_eq!(
        rendered.get("cache-control").unwrap(),
        "private,max-age=120,stale-while-revalidate=30,vary-by-locale,vary-by-session"
    );
    assert_eq!(
        rendered.get("surrogate-key").unwrap(),
        "locale-cache route-cache"
    );
    assert_eq!(rendered.get("X-Trace").unwrap(), "preserve");
}

#[test]
fn response_composition_materializes_typed_annotations_once() {
    let cache_hint = TypedCacheHint::new(
        CacheVisibility::Public,
        60,
        None,
        false,
        false,
        false,
        ["page-cache"],
    )
    .unwrap();
    let response = LiveResponseComposition::json(
        StatusCode::OK,
        BTreeMap::from([("ok".to_string(), "true".to_string())]),
    )
    .with_annotation(
        LiveResponseAnnotations::default()
            .metadata(Some(TypedMetadata::new().with_title("Demo").unwrap()))
            .cache_hint(Some(cache_hint.clone()))
            .cache_headers(LiveCacheHeaders::from_parts(
                BTreeMap::from([("X-Trace".to_string(), "preserve".to_string())]),
                Some(&cache_hint),
            ))
            .route("account.dashboard")
            .locale("en-GB"),
    );

    let response = response.into_response();
    assert_eq!(
        response
            .headers()
            .get("x-coil-wasm-metadata-title")
            .unwrap(),
        "Demo"
    );
    assert_eq!(
        response
            .headers()
            .get("x-coil-wasm-cache-control")
            .unwrap(),
        "public,max-age=60"
    );
    assert_eq!(
        response.headers().get("x-coil-route").unwrap(),
        "account.dashboard"
    );
    assert_eq!(response.headers().get("x-coil-locale").unwrap(), "en-GB");
    assert_eq!(response.headers().get("X-Trace").unwrap(), "preserve");
}

#[tokio::test]
async fn html_response_composition_renders_structured_html_graphs() {
    let response = LiveResponseComposition::html(
        StatusCode::OK,
        crate::live::LiveHtmlResponseGraph::new("<html><body><main>base</main></body></html>")
            .with_request_surface(Some(&coil_wasm::TypedExecutionOutput {
                surface: coil_wasm::ExtensionPointKind::Page,
                status: 200,
                body: coil_wasm::TypedResponseBody::HtmlDocument(
                    "<html><body><section>request</section></body></html>".to_string(),
                ),
                metadata: coil_wasm::TypedMetadata::new(),
                cache_hint: None,
            }))
            .with_render_hook(
                "hook-1",
                Some(&coil_wasm::TypedExecutionOutput {
                    surface: coil_wasm::ExtensionPointKind::RenderHook,
                    status: 200,
                    body: coil_wasm::TypedResponseBody::HtmlFragment(
                        "<aside>hook</aside>".to_string(),
                    ),
                    metadata: coil_wasm::TypedMetadata::new(),
                    cache_hint: None,
                }),
            ),
    );

    let response = response.into_response();
    let body = to_bytes(response.into_body(), usize::MAX).await.unwrap();
    assert_eq!(
        body.as_ref(),
        b"<html><body><main>base</main><section>request</section><aside>hook</aside></body></html>"
    );
}